@prismer/sdk 1.7.1 → 1.7.4

package/dist/cli.js

@@ -6,6 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,8 +26,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  getAPIClient: () => getAPIClient,
+  getIMClient: () => getIMClient
+});
+module.exports = __toCommonJS(cli_exports);
 var import_commander = require("commander");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
@@ -224,10 +235,11 @@ var RealtimeWSClient = class extends TypedEmitter {
   joinConversation(conversationId) {
     this.sendRaw({ type: "conversation.join", payload: { conversationId } });
   }
-  sendMessage(conversationId, content, type = "text") {
+  sendMessage(conversationId, content, options) {
+    const opts = typeof options === "string" ? { type: options } : options;
     this.sendRaw({
       type: "message.send",
-      payload: { conversationId, content, type },
+      payload: { conversationId, content, type: opts?.type ?? "text", ...opts?.metadata ? { metadata: opts.metadata } : {}, ...opts?.parentId ? { parentId: opts.parentId } : {} },
       requestId: `msg-${++this.pingCounter}`
     });
   }
@@ -947,8 +959,8 @@ var OfflineManager = class extends OfflineEmitter {
   // ── Read cache ────────────────────────────────────────────
   async readFromCache(path2, query) {
     if (/\/api\/im\/conversations$/.test(path2)) {
-      const convos2 = await this.storage.getConversations({ limit: 50 });
-      if (convos2.length > 0) return { ok: true, data: convos2 };
+      const convos = await this.storage.getConversations({ limit: 50 });
+      if (convos.length > 0) return { ok: true, data: convos };
     }
     const msgMatch = path2.match(/\/api\/im\/messages\/([^/]+)$/);
     if (msgMatch) {
@@ -967,7 +979,7 @@ var OfflineManager = class extends OfflineEmitter {
     if (!result?.ok || !result?.data) return;
     try {
       if (/\/api\/im\/conversations$/.test(path2) && Array.isArray(result.data)) {
-        const convos2 = result.data.map((c) => ({
+        const convos = result.data.map((c) => ({
           id: c.id,
           type: c.type ?? "direct",
           title: c.title,
@@ -978,7 +990,7 @@ var OfflineManager = class extends OfflineEmitter {
           metadata: c.metadata,
           updatedAt: c.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
         }));
-        await this.storage.putConversations(convos2);
+        await this.storage.putConversations(convos);
       }
       const msgMatch = path2.match(/\/api\/im\/messages\/([^/]+)$/);
       if (msgMatch && Array.isArray(result.data)) {
@@ -1113,6 +1125,317 @@ var ENVIRONMENTS = {
   production: "https://prismer.cloud"
 };
 
+// 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");
+
+// 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 AccountClient = class {
   constructor(_r) {
@@ -1238,8 +1561,8 @@ var MessagesClient = class {
     return this._r("GET", `/api/im/messages/${conversationId}`, void 0, query);
   }
   /** Edit a message */
-  async edit(conversationId, messageId, content) {
-    return this._r("PATCH", `/api/im/messages/${conversationId}/${messageId}`, { content });
+  async edit(conversationId, messageId, content, options) {
+    return this._r("PATCH", `/api/im/messages/${conversationId}/${messageId}`, { content, ...options?.metadata ? { metadata: options.metadata } : {} });
   }
   /** Delete a message */
   async delete(conversationId, messageId) {
@@ -1326,6 +1649,560 @@ var WorkspaceClient = class {
     return this._r("GET", "/api/im/workspace/mentions/autocomplete", void 0, q);
   }
 };
+var TasksClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a new task */
+  async create(options) {
+    return this._r("POST", "/api/im/tasks", options);
+  }
+  /** List tasks with optional filters */
+  async list(options) {
+    const query = {};
+    if (options?.status) query.status = options.status;
+    if (options?.capability) query.capability = options.capability;
+    if (options?.assigneeId) query.assigneeId = options.assigneeId;
+    if (options?.creatorId) query.creatorId = options.creatorId;
+    if (options?.scheduleType) query.scheduleType = options.scheduleType;
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.cursor) query.cursor = options.cursor;
+    return this._r("GET", "/api/im/tasks", void 0, query);
+  }
+  /** Get task details with logs */
+  async get(taskId) {
+    return this._r("GET", `/api/im/tasks/${taskId}`);
+  }
+  /** Update a task */
+  async update(taskId, options) {
+    return this._r("PATCH", `/api/im/tasks/${taskId}`, options);
+  }
+  /** Claim a pending task */
+  async claim(taskId) {
+    return this._r("POST", `/api/im/tasks/${taskId}/claim`);
+  }
+  /** Report progress on a task */
+  async progress(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/progress`, options);
+  }
+  /** Complete a task with result */
+  async complete(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/complete`, options);
+  }
+  /** Fail a task with error */
+  async fail(taskId, error, metadata) {
+    return this._r("POST", `/api/im/tasks/${taskId}/fail`, { error, metadata });
+  }
+};
+var MemoryClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Create a memory file */
+  async createFile(options) {
+    return this._r("POST", "/api/im/memory/files", options);
+  }
+  /** List memory files */
+  async listFiles(options) {
+    const query = {};
+    if (options?.scope) query.scope = options.scope;
+    if (options?.path) query.path = options.path;
+    return this._r("GET", "/api/im/memory/files", void 0, query);
+  }
+  /** Get a memory file by ID */
+  async getFile(fileId) {
+    return this._r("GET", `/api/im/memory/files/${fileId}`);
+  }
+  /** Update a memory file (append, replace, or replace_section) */
+  async updateFile(fileId, options) {
+    return this._r("PATCH", `/api/im/memory/files/${fileId}`, options);
+  }
+  /** Delete a memory file */
+  async deleteFile(fileId) {
+    return this._r("DELETE", `/api/im/memory/files/${fileId}`);
+  }
+  /** Compact conversation messages into a summary */
+  async compact(options) {
+    return this._r("POST", "/api/im/memory/compact", options);
+  }
+  /** Get compaction summaries for a conversation */
+  async getCompaction(conversationId) {
+    return this._r("GET", `/api/im/memory/compact/${conversationId}`);
+  }
+  /** Load memory for session context */
+  async load(scope) {
+    const query = {};
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/memory/load", void 0, query);
+  }
+};
+var IdentityClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get server public key */
+  async getServerKey() {
+    return this._r("GET", "/api/im/keys/server");
+  }
+  /** Register or rotate an identity key */
+  async registerKey(options) {
+    return this._r("PUT", "/api/im/keys/identity", options);
+  }
+  /** Get a user's identity key */
+  async getKey(userId) {
+    return this._r("GET", `/api/im/keys/identity/${userId}`);
+  }
+  /** Revoke own identity key */
+  async revokeKey() {
+    return this._r("POST", "/api/im/keys/identity/revoke");
+  }
+  /** Get key audit log for a user */
+  async getAuditLog(userId) {
+    return this._r("GET", `/api/im/keys/audit/${userId}`);
+  }
+  /** Verify key audit log integrity */
+  async verifyAuditLog(userId) {
+    return this._r("GET", `/api/im/keys/audit/${userId}/verify`);
+  }
+};
+var SecurityClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** Get conversation security settings */
+  async getConversationSecurity(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}/security`);
+  }
+  /** Update conversation security settings */
+  async setConversationSecurity(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/security`, options);
+  }
+  /** Upload a public key for a conversation */
+  async uploadKey(conversationId, publicKey, algorithm) {
+    const body = { publicKey };
+    if (algorithm) body.algorithm = algorithm;
+    return this._r("POST", `/api/im/conversations/${conversationId}/keys`, body);
+  }
+  /** Get keys for a conversation */
+  async getKeys(conversationId) {
+    return this._r("GET", `/api/im/conversations/${conversationId}/keys`);
+  }
+  /** Revoke a key for a specific user in a conversation */
+  async revokeKey(conversationId, keyUserId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}/keys/${keyUserId}`);
+  }
+};
+var EvolutionClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  // ── Public endpoints (no auth required) ──
+  /** Get evolution stats */
+  async getStats() {
+    return this._r("GET", "/api/im/evolution/public/stats");
+  }
+  /** Get hot/trending genes */
+  async getHotGenes(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/public/hot", void 0, query);
+  }
+  /** Browse published genes */
+  async browseGenes(options) {
+    const query = {};
+    if (options?.category) query.category = options.category;
+    if (options?.search) query.search = options.search;
+    if (options?.sort) query.sort = options.sort;
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    return this._r("GET", "/api/im/evolution/public/genes", void 0, query);
+  }
+  /** Get a public gene by ID */
+  async getPublicGene(geneId) {
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}`);
+  }
+  /** Get capsules for a public gene */
+  async getGeneCapsules(geneId, limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}/capsules`, void 0, query);
+  }
+  /** Get gene lineage (parent + children) */
+  async getGeneLineage(geneId) {
+    return this._r("GET", `/api/im/evolution/public/genes/${geneId}/lineage`);
+  }
+  /** Get public evolution feed */
+  async getFeed(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/public/feed", void 0, query);
+  }
+  // ── Authenticated endpoints ──
+  /** Analyze signals and get gene recommendation */
+  async analyze(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/analyze", body, q);
+  }
+  /** Record an outcome (success/failure) for a gene */
+  async record(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/record", body, q);
+  }
+  /**
+   * One-step evolution: analyze context → get gene recommendation → auto-record outcome.
+   * Combines analyze() + record() into a single call for the common case.
+   *
+   * Usage:
+   *   const result = await client.evolution.evolve({
+   *     error: 'Connection timeout after 10s',
+   *     outcome: 'success',
+   *     score: 0.85,
+   *     summary: 'Fixed with exponential backoff',
+   *   });
+   */
+  async evolve(options) {
+    const { outcome, score, summary, strategy_used, scope, ...analyzeOpts } = options;
+    const analysis = await this.analyze({ ...analyzeOpts, ...scope ? { scope } : {} });
+    if (!analysis.ok || !analysis.data) {
+      return { ok: false, error: analysis.error };
+    }
+    const data = analysis.data;
+    const geneId = data.gene_id;
+    if (geneId && (data.action === "apply_gene" || data.action === "explore")) {
+      const recordResult = await this.record({
+        gene_id: geneId,
+        signals: data.signals || analyzeOpts.signals || [],
+        outcome,
+        score: score ?? (outcome === "success" ? 0.8 : 0.2),
+        summary: summary || `${outcome === "success" ? "Resolved" : "Failed to resolve"} using ${geneId}`,
+        strategy_used,
+        ...scope ? { scope } : {}
+      });
+      return {
+        ok: true,
+        data: {
+          analysis: data,
+          recorded: true,
+          edge_updated: recordResult.data?.edge_updated
+        }
+      };
+    }
+    return {
+      ok: true,
+      data: { analysis: data, recorded: false }
+    };
+  }
+  /** Trigger gene distillation */
+  async distill(dryRun) {
+    const query = {};
+    if (dryRun) query.dry_run = "true";
+    return this._r("POST", "/api/im/evolution/distill", void 0, query);
+  }
+  /** List own genes */
+  async listGenes(signals, scope) {
+    const query = {};
+    if (signals) query.signals = signals;
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/evolution/genes", void 0, query);
+  }
+  /** Create a new gene */
+  async createGene(options) {
+    const { scope, ...body } = options;
+    const q = {};
+    if (scope) q.scope = scope;
+    return this._r("POST", "/api/im/evolution/genes", body, q);
+  }
+  /** Delete a gene */
+  async deleteGene(geneId) {
+    return this._r("DELETE", `/api/im/evolution/genes/${encodeURIComponent(geneId)}`);
+  }
+  /** Publish a gene. Pass skipCanary=true to bypass canary validation (MVP/admin). */
+  async publishGene(geneId, options) {
+    return this._r("POST", `/api/im/evolution/genes/${encodeURIComponent(geneId)}/publish`, options?.skipCanary ? { skipCanary: true } : void 0);
+  }
+  /** Import a published gene */
+  async importGene(geneId) {
+    return this._r("POST", "/api/im/evolution/genes/import", { gene_id: geneId });
+  }
+  /** Fork a gene with modifications */
+  async forkGene(options) {
+    return this._r("POST", "/api/im/evolution/genes/fork", options);
+  }
+  /** Get signal-gene edges */
+  async getEdges(options) {
+    const query = {};
+    if (options?.signalKey) query.signal_key = options.signalKey;
+    if (options?.geneId) query.gene_id = options.geneId;
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.scope) query.scope = options.scope;
+    return this._r("GET", "/api/im/evolution/edges", void 0, query);
+  }
+  /** Get agent personality profile */
+  async getPersonality(agentId) {
+    return this._r("GET", `/api/im/evolution/personality/${agentId}`);
+  }
+  /** Get own capsule history */
+  async getCapsules(options) {
+    const query = {};
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.scope) query.scope = options.scope;
+    return this._r("GET", "/api/im/evolution/capsules", void 0, query);
+  }
+  /** Get evolution report */
+  async getReport(agentId, scope) {
+    const query = {};
+    if (agentId) query.agent_id = agentId;
+    if (scope) query.scope = scope;
+    return this._r("GET", "/api/im/evolution/report", void 0, query);
+  }
+  /** List available evolution scopes */
+  async listScopes() {
+    return this._r("GET", "/api/im/evolution/scopes");
+  }
+  // ─── v0.3.1: Stories, Metrics, Skills ──────────────
+  /** Get recent evolution stories (for L1 narrative embedding) */
+  async getStories(options) {
+    const query = {};
+    if (options?.limit != null) query.limit = String(options.limit);
+    if (options?.since != null) query.since = String(options.since);
+    return this._r("GET", "/api/im/evolution/stories", void 0, query);
+  }
+  /** Get north-star metrics comparison (standard vs hypergraph) */
+  async getMetrics() {
+    return this._r("GET", "/api/im/evolution/metrics");
+  }
+  /** Trigger metrics collection snapshot */
+  async collectMetrics(windowHours) {
+    return this._r("POST", "/api/im/evolution/metrics/collect", { window_hours: windowHours ?? 1 });
+  }
+  /** Search skills catalog */
+  async searchSkills(options) {
+    const q = {};
+    if (options?.query) q.query = options.query;
+    if (options?.category) q.category = options.category;
+    if (options?.limit != null) q.limit = String(options.limit);
+    return this._r("GET", "/api/im/skills/search", void 0, q);
+  }
+  /** Get skill catalog stats */
+  async getSkillStats() {
+    return this._r("GET", "/api/im/skills/stats");
+  }
+  /** Install a skill — creates Gene + returns content + install guide */
+  async installSkill(slugOrId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  }
+  /** Uninstall a skill */
+  async uninstallSkill(slugOrId) {
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  }
+  /** List installed skills for this agent */
+  async installedSkills() {
+    return this._r("GET", "/api/im/skills/installed");
+  }
+  /** Get full skill content (SKILL.md + package info) */
+  async getSkillContent(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+  }
+  /** Create/submit a community skill */
+  async createSkill(input) {
+    return this._r("POST", "/api/im/skills", input);
+  }
+  /** Star a skill (increment community rating) */
+  async starSkill(skillId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+  }
+  /**
+   * Install a skill and write SKILL.md to local filesystem.
+   * Combines cloud install + local file sync for Claude Code / OpenClaw / OpenCode.
+   * @param slugOrId - Skill slug or ID
+   * @param options - Local install options
+   */
+  async installSkillLocal(slugOrId, options) {
+    const result = await this.installSkill(slugOrId);
+    if (!result.ok || !result.data) return result;
+    let content = result.data.skill?.content || "";
+    if (!content) {
+      const contentResult = await this.getSkillContent(slugOrId);
+      content = contentResult.data?.content || "";
+    }
+    if (!content) {
+      return { ...result, data: { ...result.data, localPaths: [] } };
+    }
+    const rawSlug = result.data.skill?.slug || slugOrId;
+    const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
+    if (!slug) {
+      return { ...result, data: { ...result.data, localPaths: [] } };
+    }
+    const localPaths = [];
+    try {
+      const 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 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": 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)
+      };
+      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");
+          localPaths.push(filePath);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { ...result, data: { ...result.data, localPaths } };
+  }
+  /**
+   * Uninstall a skill and remove local SKILL.md files.
+   */
+  async uninstallSkillLocal(slugOrId) {
+    const result = await this.uninstallSkill(slugOrId);
+    const removedPaths = [];
+    const slug = safeSlug(slugOrId);
+    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    try {
+      const 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 dirs = [
+        path2.join(home, ".claude", "skills", slug),
+        path2.join(home, ".openclaw", "skills", slug),
+        path2.join(home, ".config", "opencode", "skills", slug),
+        path2.join(pluginBase, "skills", slug)
+      ];
+      for (const dir of dirs) {
+        try {
+          if (fs2.existsSync(dir)) {
+            fs2.rmSync(dir, { recursive: true });
+            removedPaths.push(dir);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+  }
+  /**
+   * Sync all installed skills to local filesystem.
+   */
+  async syncSkillsLocal(options) {
+    const installed = await this.installedSkills();
+    if (!installed.ok || !installed.data) return { synced: 0, failed: 0, paths: [] };
+    let synced = 0;
+    let failed = 0;
+    const paths = [];
+    for (const record of installed.data) {
+      const rawSlug = record.skill?.slug;
+      if (!rawSlug) {
+        failed++;
+        continue;
+      }
+      const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
+      if (!slug) {
+        failed++;
+        continue;
+      }
+      try {
+        const contentResult = await this.getSkillContent(slug);
+        const content = contentResult.data?.content;
+        if (!content) {
+          failed++;
+          continue;
+        }
+        const 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 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)
+        };
+        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");
+            paths.push(filePath);
+          } catch {
+          }
+        }
+        synced++;
+      } catch {
+        failed++;
+      }
+    }
+    return { synced, failed, paths };
+  }
+  /** Export a Gene as a Skill */
+  async exportAsSkill(geneId, options) {
+    return this._r("POST", `/api/im/evolution/genes/${geneId}/export-skill`, options);
+  }
+  // ─── P0: Report, Achievements, Sync ──────────────
+  /** Submit a raw-context evolution report (auto-creates signals + gene match) */
+  async submitReport(options) {
+    return this._r("POST", "/api/im/evolution/report", {
+      raw_context: options.rawContext,
+      outcome: options.outcome,
+      task_context: options.taskContext,
+      task_error: options.taskError,
+      task_id: options.taskId,
+      metadata: options.metadata
+    });
+  }
+  /** Get status of a submitted report by traceId */
+  async getReportStatus(traceId) {
+    return this._r("GET", `/api/im/evolution/report/${traceId}`);
+  }
+  /** Get evolution achievements for the current agent */
+  async getAchievements() {
+    return this._r("GET", "/api/im/evolution/achievements");
+  }
+  /** Get a sync snapshot (global gene/edge state since a sequence number) */
+  async getSyncSnapshot(since) {
+    const query = { scope: "global" };
+    if (since != null) query.since = String(since);
+    return this._r("GET", "/api/im/evolution/sync/snapshot", void 0, query);
+  }
+  /** Bidirectional sync: push local outcomes and pull remote updates */
+  async sync(options) {
+    const body = {};
+    if (options?.pushOutcomes) body.push = { outcomes: options.pushOutcomes };
+    if (options?.pullSince != null) body.pull = { since: options.pullSince };
+    return this._r("POST", "/api/im/evolution/sync", body);
+  }
+};
+function safeSlug(input) {
+  return input.replace(/[\/\\]/g, "").replace(/\.\./g, "").replace(/\0/g, "");
+}
 function guessMimeType(fileName) {
   const ext = fileName.split(".").pop()?.toLowerCase() || "";
   const map = {
@@ -1564,6 +2441,11 @@ var IMClient = class {
     this.bindings = new BindingsClient(request);
     this.credits = new CreditsClient(request);
     this.workspace = new WorkspaceClient(request);
+    this.tasks = new TasksClient(request);
+    this.memory = new MemoryClient(request);
+    this.identity = new IdentityClient(request);
+    this.security = new SecurityClient(request);
+    this.evolution = new EvolutionClient(request);
     this.files = new FilesClient(request, wsBase, fetchFn, getAuthHeaders);
     this.realtime = new IMRealtimeClient(wsBase);
     this.offline = offlineManager ?? null;
@@ -1733,41 +2615,2386 @@ var PrismerClient = class {
   }
 };
 
-// src/cli.ts
-var cliVersion = "1.3.3";
-try {
-  const pkgPath = path.join(__dirname, "..", "package.json");
-  const pkg = JSON.parse(fs.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");
-function ensureConfigDir() {
+// src/commands/im.ts
+function register(parent, getIMClient2, _getAPIClient) {
+  const im = parent.command("im").description("IM messaging, groups, conversations, and credits");
+  im.command("send <user-id> <message>").description("Send a direct message to a user").option("-t, --type <type>", "Message type: text, markdown, code, file, etc.", "text").option("--reply-to <msg-id>", "Reply to a specific message ID (parentId)").option("--json", "Output raw JSON response").action(async (userId, message, opts) => {
+    const client = getIMClient2();
+    try {
+      const sendOpts = {
+        type: opts.type
+      };
+      if (opts.replyTo) sendOpts.parentId = opts.replyTo;
+      const res = await client.im.direct.send(userId, message, sendOpts);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Message sent (conversationId: ${res.data?.conversationId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("messages <user-id>").description("View direct message history with a user").option("-n, --limit <n>", "Max number of messages to fetch", "20").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.direct.getMessages(userId, { limit: parseInt(opts.limit, 10) });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const msgs = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(msgs, null, 2) + "\n");
+        return;
+      }
+      if (msgs.length === 0) {
+        process.stdout.write("No messages.\n");
+        return;
+      }
+      for (const m of msgs) {
+        const ts = m.createdAt ? new Date(m.createdAt).toLocaleString() : "";
+        process.stdout.write(`[${ts}] ${m.senderId || "?"}: ${m.content}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("edit <conversation-id> <message-id> <content>").description("Edit an existing message").option("--json", "Output raw JSON response").action(async (convId, msgId, content, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.messages.edit(convId, msgId, content);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Message ${msgId} updated.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("delete <conversation-id> <message-id>").description("Delete a message").option("--json", "Output raw JSON response").action(async (convId, msgId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.messages.delete(convId, msgId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Message ${msgId} deleted.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("discover").description("Discover available agents").option("--type <type>", "Filter by agent type").option("--capability <cap>", "Filter by capability").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const discoverOpts = {};
+      if (opts.type) discoverOpts.type = opts.type;
+      if (opts.capability) discoverOpts.capability = opts.capability;
+      const res = await client.im.contacts.discover(Object.keys(discoverOpts).length ? discoverOpts : void 0);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const agents = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(agents, null, 2) + "\n");
+        return;
+      }
+      if (agents.length === 0) {
+        process.stdout.write("No agents found.\n");
+        return;
+      }
+      process.stdout.write(
+        "Username".padEnd(20) + "Type".padEnd(14) + "Status".padEnd(10) + "Display Name\n"
+      );
+      for (const a of agents) {
+        process.stdout.write(
+          `${(a.username || "").padEnd(20)}${(a.agentType || "").padEnd(14)}${(a.status || "").padEnd(10)}${a.displayName || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("contacts").description("List contacts").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.contacts.list();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const contacts = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(contacts, null, 2) + "\n");
+        return;
+      }
+      if (contacts.length === 0) {
+        process.stdout.write("No contacts.\n");
+        return;
+      }
+      process.stdout.write(
+        "Username".padEnd(20) + "Role".padEnd(10) + "Unread".padEnd(8) + "Display Name\n"
+      );
+      for (const c of contacts) {
+        process.stdout.write(
+          `${(c.username || "").padEnd(20)}${(c.role || "").padEnd(10)}${String(c.unreadCount ?? 0).padEnd(8)}${c.displayName || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("conversations").description("List conversations").option("--unread", "Show only conversations with unread messages").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const listOpts = {};
+      if (opts.unread) {
+        listOpts.withUnread = true;
+        listOpts.unreadOnly = true;
+      }
+      const res = await client.im.conversations.list(listOpts);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const list = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+        return;
+      }
+      if (list.length === 0) {
+        process.stdout.write("No conversations.\n");
+        return;
+      }
+      for (const c of list) {
+        const unread = c.unreadCount ? ` (${c.unreadCount} unread)` : "";
+        process.stdout.write(`${c.id || ""}  ${c.type || ""}  ${c.title || ""}${unread}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("read <conversation-id>").description("Mark a conversation as read").action(async (convId) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.conversations.markAsRead(convId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      process.stdout.write("Marked as read.\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  const groups = im.command("groups").description("Group chat management");
+  groups.command("create <title>").description("Create a new group").option("-m, --members <ids>", "Comma-separated member user IDs to add").option("--json", "Output raw JSON response").action(async (title, opts) => {
+    const client = getIMClient2();
+    try {
+      const members = opts.members ? opts.members.split(",").map((s) => s.trim()) : [];
+      const res = await client.im.groups.create({ title, members });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Group created (groupId: ${res.data?.groupId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  groups.command("list").description("List groups you belong to").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.groups.list();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const list = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+        return;
+      }
+      if (list.length === 0) {
+        process.stdout.write("No groups.\n");
+        return;
+      }
+      for (const g of list) {
+        process.stdout.write(`${g.groupId || ""}  ${g.title || ""} (${g.members?.length || "?"} members)
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  groups.command("send <group-id> <message>").description("Send a message to a group").option("--json", "Output raw JSON response").action(async (groupId, message, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.groups.send(groupId, message);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write("Message sent to group.\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  groups.command("messages <group-id>").description("View group message history").option("-n, --limit <n>", "Max number of messages to fetch", "20").option("--json", "Output raw JSON response").action(async (groupId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.groups.getMessages(groupId, { limit: parseInt(opts.limit, 10) });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const msgs = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(msgs, null, 2) + "\n");
+        return;
+      }
+      if (msgs.length === 0) {
+        process.stdout.write("No messages.\n");
+        return;
+      }
+      for (const m of msgs) {
+        const ts = m.createdAt ? new Date(m.createdAt).toLocaleString() : "";
+        process.stdout.write(`[${ts}] ${m.senderId || "?"}: ${m.content}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("me").description("Show current identity, agent card, credits, and stats").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.account.me();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const d = res.data;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(d, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Display Name: ${d?.user?.displayName || "-"}
+`);
+      process.stdout.write(`Username:     ${d?.user?.username || "-"}
+`);
+      process.stdout.write(`Role:         ${d?.user?.role || "-"}
+`);
+      process.stdout.write(`Agent Type:   ${d?.agentCard?.agentType || "-"}
+`);
+      process.stdout.write(`Credits:      ${d?.credits?.balance ?? "-"}
+`);
+      process.stdout.write(`Messages:     ${d?.stats?.messagesSent ?? "-"}
+`);
+      process.stdout.write(`Unread:       ${d?.stats?.unreadCount ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("credits").description("Show credits balance").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.credits.get();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Balance: ${res.data?.balance ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("transactions").description("Show credit transaction history").option("-n, --limit <n>", "Max number of transactions to fetch", "20").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.credits.transactions({ limit: parseInt(opts.limit, 10) });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const txns = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(txns, null, 2) + "\n");
+        return;
+      }
+      if (txns.length === 0) {
+        process.stdout.write("No transactions.\n");
+        return;
+      }
+      process.stdout.write(
+        "Date".padEnd(24) + "Type".padEnd(20) + "Amount".padEnd(12) + "Description\n"
+      );
+      for (const t of txns) {
+        const date = t.createdAt ? new Date(t.createdAt).toLocaleString() : "";
+        process.stdout.write(
+          `${date.padEnd(24)}${(t.type || "").padEnd(20)}${String(t.amount ?? "").padEnd(12)}${t.description || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("heartbeat").description("Send agent heartbeat (online/busy/offline) with optional load").option("--status <status>", "Presence status: online, busy, or offline", "online").option("--load <n>", "Current load factor (0.0 to 1.0)").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const body = { status: opts.status };
+      if (opts.load !== void 0) {
+        const load = parseFloat(opts.load);
+        if (!isNaN(load)) body.load = load;
+      }
+      const res = await client.im.account._r("POST", "/api/im/agents/heartbeat", body);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Heartbeat sent (status: ${opts.status}${opts.load !== void 0 ? `, load: ${opts.load}` : ""}).
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("health").description("Check IM service health").action(async () => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.health();
+      if (!res.ok) {
+        process.stderr.write(`IM Service: ERROR
+`);
+        process.stderr.write(`${JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      process.stdout.write("IM Service: OK\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/context.ts
+function register2(parent, _getIMClient, getAPIClient2) {
+  const ctx = parent.command("context").description("Context loading, searching, and caching");
+  ctx.command("load <urls...>").description("Load one or more URLs into context").option("-f, --format <fmt>", "output format: hqcc, raw, or both", "hqcc").option("--json", "output raw JSON response").action(async (urls, opts) => {
+    const client = getAPIClient2();
+    try {
+      const input = urls.length === 1 ? urls[0] : urls;
+      const format = opts.format;
+      const res = await client.load(input, {
+        return: { format }
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.success) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const results = res.results ?? (res.result ? [res.result] : []);
+      if (results.length === 0) {
+        process.stdout.write("No results returned.\n");
+        return;
+      }
+      for (const item of results) {
+        process.stdout.write(`
+--- ${item.url ?? item.input ?? "result"} ---
+`);
+        const hqcc = item.hqcc ?? item.content ?? "";
+        if (hqcc) {
+          const truncated = hqcc.length > 2e3 ? hqcc.slice(0, 2e3) + "... [truncated]" : hqcc;
+          process.stdout.write(truncated + "\n");
+        }
+        if (item.cached !== void 0) {
+          process.stdout.write(`[cached: ${item.cached}]
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  ctx.command("search <query>").description("Search for content using a natural language query").option("-k, --top-k <n>", "number of results to return", "5").option("--json", "output raw JSON response").action(async (query, opts) => {
+    const client = getAPIClient2();
+    try {
+      const topK = parseInt(opts.topK, 10);
+      const res = await client.search(query, { topK });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.success) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const results = res.results ?? (res.result ? [res.result] : []);
+      if (results.length === 0) {
+        process.stdout.write("No results found.\n");
+        return;
+      }
+      process.stdout.write(`Search results for: "${query}"
+
+`);
+      results.forEach((item, i) => {
+        process.stdout.write(`[${i + 1}] ${item.url ?? item.input ?? "result"}
+`);
+        const hqcc = item.hqcc ?? item.content ?? "";
+        if (hqcc) {
+          const truncated = hqcc.length > 2e3 ? hqcc.slice(0, 2e3) + "... [truncated]" : hqcc;
+          process.stdout.write(truncated + "\n");
+        }
+        process.stdout.write("\n");
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  ctx.command("save <url> <hqcc>").description("Save a URL and its HQCC content to the context cache").option("--json", "output raw JSON response").action(async (url, hqcc, opts) => {
+    const client = getAPIClient2();
+    try {
+      const res = await client.save({ url, hqcc });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.success) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(`Saved: ${url}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/evolve.ts
+function parseSignals(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) return parsed.map(String);
+    } catch {
+    }
+  }
+  return trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function handleError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
+function printResult(res, label) {
+  if (!res.ok) {
+    const errMsg = res.error && typeof res.error === "object" && "message" in res.error ? res.error.message : JSON.stringify(res.error);
+    process.stderr.write(`Error: ${errMsg || "Unknown error"}
+`);
+    process.exit(1);
+  }
+  if (label) {
+    process.stdout.write(`${label}
+`);
+  }
+}
+function register3(parent, getIMClient2, _getAPIClient) {
+  const evolve = parent.command("evolve").description("Evolution engine \u2014 analyze signals, manage genes, track learning");
+  evolve.command("analyze").description("Analyze signals to find matching evolution strategies").option("-e, --error <msg>", "error message to analyze").option("-s, --signals <signals>", "signals as JSON array or comma-separated list").option("--task-status <status>", "task status (e.g. failed, timeout)").option("--provider <name>", "provider name (e.g. openai, exa)").option("--stage <stage>", "pipeline stage").option("--severity <level>", "severity level (low, medium, high, critical)").option("--tags <tags>", "comma-separated tags").option("--scope <scope>", "evolution scope (default: global)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const signals = parseSignals(opts.signals);
+      const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+      const res = await client.im.evolution.analyze({
+        signals,
+        error: opts.error,
+        task_status: opts.taskStatus,
+        provider: opts.provider,
+        stage: opts.stage,
+        severity: opts.severity,
+        tags,
+        scope: opts.scope
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        const matches = data.matches;
+        const count = matches?.length ?? 0;
+        process.stdout.write(`Matched ${count} gene(s)
+`);
+        if (matches && count > 0) {
+          for (const m of matches) {
+            const id = m.gene_id ?? m.id ?? "?";
+            const title = m.title ?? m.name ?? "";
+            const score = m.score !== void 0 ? ` (score: ${m.score})` : "";
+            process.stdout.write(`  \u2022 ${id}${title ? ` \u2014 ${title}` : ""}${score}
+`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("record").description("Record an outcome against an evolution gene").requiredOption("-g, --gene <id>", "gene ID to record against").requiredOption("-o, --outcome <outcome>", "outcome: success, failure, partial").option("-s, --signals <signals>", "signals as JSON array or comma-separated list").option("--score <n>", "outcome score (0-1)").option("--summary <text>", "brief summary of the outcome").option("--scope <scope>", "evolution scope (default: global)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const signals = parseSignals(opts.signals);
+      const score = opts.score !== void 0 ? parseFloat(opts.score) : void 0;
+      const res = await client.im.evolution.record({
+        gene_id: opts.gene,
+        signals,
+        outcome: opts.outcome,
+        score,
+        summary: opts.summary,
+        scope: opts.scope
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Recorded outcome "${opts.outcome}" for gene ${opts.gene}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("report").description("Submit a full evolution report (error + status context)").requiredOption("-e, --error <msg>", "raw error message or context").requiredOption("--status <outcome>", "final task outcome (success, failure, partial)").option("--task <context>", "task context description").option("--wait", "poll for report completion (max 60s)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.submitReport({
+        rawContext: opts.error,
+        outcome: opts.status,
+        taskContext: opts.task
+      });
+      if (opts.json && !opts.wait) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        const errMsg = res.error && typeof res.error === "object" && "message" in res.error ? res.error.message : JSON.stringify(res.error);
+        process.stderr.write(`Error: ${errMsg || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const submitData = res.data;
+      const traceId = submitData?.trace_id;
+      if (!opts.wait || !traceId) {
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        } else {
+          process.stdout.write(`Report submitted. trace_id: ${traceId ?? "unknown"}
+`);
+          if (submitData?.fast_signals) {
+            process.stdout.write(`Fast signals: ${JSON.stringify(submitData.fast_signals)}
+`);
+          }
+        }
+        return;
+      }
+      if (!opts.json) {
+        process.stdout.write(`Waiting for report ${traceId} `);
+      }
+      const maxIterations = 30;
+      let lastStatus;
+      for (let i = 0; i < maxIterations; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        if (!opts.json) process.stdout.write(".");
+        const statusRes = await client.im.evolution.getReportStatus(traceId);
+        if (!statusRes.ok) break;
+        const statusData = statusRes.data;
+        lastStatus = statusData;
+        if (statusData?.status === "done" || statusData?.status === "complete" || statusData?.status === "completed") {
+          if (!opts.json) {
+            process.stdout.write("\n");
+            process.stdout.write(`Status: ${statusData.status}
+`);
+            if (statusData.root_cause) process.stdout.write(`Root cause: ${statusData.root_cause}
+`);
+            if (statusData.extracted_signals) process.stdout.write(`Extracted signals: ${JSON.stringify(statusData.extracted_signals)}
+`);
+          } else {
+            process.stdout.write(JSON.stringify({ trace_id: traceId, ...statusData }, null, 2) + "\n");
+          }
+          return;
+        }
+      }
+      if (!opts.json) {
+        process.stdout.write("\n");
+        process.stdout.write(`Timed out waiting for report. Last status: ${JSON.stringify(lastStatus)}
+`);
+      } else {
+        process.stdout.write(JSON.stringify({ trace_id: traceId, status: "timeout", last: lastStatus }, null, 2) + "\n");
+      }
+      process.exit(1);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("report-status <trace-id>").description("Check the status of a submitted evolution report").option("--json", "output raw JSON response").action(async (traceId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getReportStatus(traceId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      process.stdout.write(`trace_id: ${traceId}
+`);
+      process.stdout.write(`status:   ${data?.status ?? "unknown"}
+`);
+      if (data?.root_cause) process.stdout.write(`root_cause: ${data.root_cause}
+`);
+      if (data?.extracted_signals) process.stdout.write(`extracted_signals: ${JSON.stringify(data.extracted_signals)}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("create").description("Create a new evolution gene").requiredOption("-c, --category <cat>", "gene category").requiredOption("-s, --signals <signals>", "trigger signals as JSON array or comma-separated list").requiredOption("--strategy <steps...>", "strategy steps (variadic)").option("-n, --name <title>", "gene title / display name").option("--scope <scope>", "evolution scope (default: global)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const signals_match = parseSignals(opts.signals) ?? [];
+      const res = await client.im.evolution.createGene({
+        category: opts.category,
+        signals_match,
+        strategy: opts.strategy,
+        title: opts.name,
+        scope: opts.scope
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const id = data?.gene_id ?? data?.id ?? "unknown";
+      process.stdout.write(`Gene created: ${id}
+`);
+      if (opts.name) process.stdout.write(`Title: ${opts.name}
+`);
+      process.stdout.write(`Category: ${opts.category}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("genes").description("List your own evolution genes").option("--scope <scope>", "filter by evolution scope").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.listGenes(void 0, opts.scope);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const genes = Array.isArray(data) ? data : data?.genes ?? data?.items ?? [];
+      if (genes.length === 0) {
+        process.stdout.write("No genes found.\n");
+        return;
+      }
+      process.stdout.write(`${genes.length} gene(s):
+`);
+      for (const g of genes) {
+        const id = g.gene_id ?? g.id ?? "?";
+        const title = g.title ?? g.name ?? "";
+        const category = g.category ? ` [${g.category}]` : "";
+        const scope = g.scope ? ` (${g.scope})` : "";
+        process.stdout.write(`  \u2022 ${id}${title ? ` \u2014 ${title}` : ""}${category}${scope}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("stats").description("Show public evolution statistics").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getStats();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        for (const [key, val] of Object.entries(data)) {
+          process.stdout.write(`${key}: ${JSON.stringify(val)}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("metrics").description("Show A/B experiment metrics").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getMetrics();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        for (const [key, val] of Object.entries(data)) {
+          process.stdout.write(`${key}: ${JSON.stringify(val)}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("achievements").description("Show your evolution achievements").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getAchievements();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const achievements = Array.isArray(data) ? data : data?.achievements ?? data?.items ?? [];
+      if (achievements.length === 0) {
+        process.stdout.write("No achievements yet.\n");
+        return;
+      }
+      process.stdout.write(`${achievements.length} achievement(s):
+`);
+      for (const a of achievements) {
+        const id = a.id ?? "?";
+        const title = a.title ?? a.name ?? "";
+        const desc = a.description ? ` \u2014 ${a.description}` : "";
+        process.stdout.write(`  \u2022 ${id}${title ? ` ${title}` : ""}${desc}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("sync").description("Get a sync snapshot of recent evolution data").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getSyncSnapshot();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        const since = data.since ?? data.timestamp ?? data.generated_at;
+        if (since) process.stdout.write(`Snapshot since: ${since}
+`);
+        const genes = data.genes;
+        const signals = data.signals;
+        if (genes !== void 0) process.stdout.write(`Genes: ${genes.length}
+`);
+        if (signals !== void 0) process.stdout.write(`Signals: ${signals.length}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("export-skill <gene-id>").description("Export a gene as a reusable skill").option("--slug <slug>", "skill slug identifier").option("--name <displayName>", "skill display name").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.exportAsSkill(geneId, {
+        slug: opts.slug,
+        displayName: opts.name
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      process.stdout.write(`Skill exported from gene: ${geneId}
+`);
+      if (data?.skill_id) process.stdout.write(`skill_id: ${data.skill_id}
+`);
+      if (data?.slug) process.stdout.write(`slug: ${data.slug}
+`);
+      if (data?.display_name) process.stdout.write(`display_name: ${data.display_name}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("scopes").description("List available evolution scopes").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.listScopes();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const scopes = Array.isArray(data) ? data : data?.scopes ?? data?.items ?? [];
+      if (scopes.length === 0) {
+        process.stdout.write("No scopes found.\n");
+        return;
+      }
+      process.stdout.write(`${scopes.length} scope(s):
+`);
+      for (const s of scopes) {
+        if (typeof s === "string") {
+          process.stdout.write(`  \u2022 ${s}
+`);
+        } else {
+          const name = s.name ?? s.scope ?? s.id ?? JSON.stringify(s);
+          process.stdout.write(`  \u2022 ${name}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("browse").description("Browse published evolution genes").option("-c, --category <cat>", "filter by category").option("--search <query>", "full-text search query").option("--sort <field>", "sort field (e.g. score, created_at)").option("-n, --limit <n>", "max results to return", "20").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const limit = parseInt(opts.limit ?? "20", 10);
+      const res = await client.im.evolution.browseGenes({
+        category: opts.category,
+        search: opts.search,
+        sort: opts.sort,
+        limit
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const genes = Array.isArray(data) ? data : data?.genes ?? data?.items ?? data?.results ?? [];
+      if (genes.length === 0) {
+        process.stdout.write("No genes found.\n");
+        return;
+      }
+      process.stdout.write(`${genes.length} gene(s):
+`);
+      for (const g of genes) {
+        const id = g.gene_id ?? g.id ?? "?";
+        const title = g.title ?? g.name ?? "";
+        const category = g.category ? ` [${g.category}]` : "";
+        const score = g.score !== void 0 ? ` score=${g.score}` : "";
+        process.stdout.write(`  \u2022 ${id}${title ? ` \u2014 ${title}` : ""}${category}${score}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  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.publishGene(geneId, { skipCanary: opts.skipCanary });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Gene ${geneId} published${opts.skipCanary ? " (skipped canary)" : " (canary phase)"}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  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.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;
+      const newId = data?.id ?? data?.gene_id ?? "unknown";
+      process.stdout.write(`Forked gene ${geneId} \u2192 ${newId}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  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 {
+      const res = await client.im.tasks.create({
+        title: opts.title,
+        description: opts.description,
+        priority: opts.priority,
+        requiredCapability: opts.capability,
+        budget: opts.budget
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task created successfully
+
+`);
+      process.stdout.write(`ID:          ${t.id}
+`);
+      process.stdout.write(`Title:       ${t.title}
+`);
+      process.stdout.write(`Status:      ${t.status}
+`);
+      process.stdout.write(`Priority:    ${t.priority}
+`);
+      if (t.description) process.stdout.write(`Description: ${t.description}
+`);
+      if (t.requiredCapability) process.stdout.write(`Capability:  ${t.requiredCapability}
+`);
+      if (t.budget !== void 0) process.stdout.write(`Budget:      ${t.budget}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("list").description("List tasks").option("--status <status>", "filter by status").option("--capability <capability>", "filter by required capability").option("-n, --limit <n>", "maximum number of tasks to return", "20").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.list({
+        status: opts.status,
+        capability: opts.capability,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const tasks = res.data;
+      if (!tasks || tasks.length === 0) {
+        process.stdout.write("No tasks found.\n");
+        return;
+      }
+      const idW = 24;
+      const statusW = 10;
+      const priorityW = 10;
+      const titleW = 40;
+      const header = "ID".padEnd(idW) + "STATUS".padEnd(statusW) + "PRIORITY".padEnd(priorityW) + "TITLE";
+      const sep = "-".repeat(idW + statusW + priorityW + titleW);
+      process.stdout.write(header + "\n");
+      process.stdout.write(sep + "\n");
+      for (const t of tasks) {
+        const title = t.title.length > titleW ? t.title.slice(0, titleW - 3) + "..." : t.title;
+        process.stdout.write(
+          String(t.id).padEnd(idW) + String(t.status).padEnd(statusW) + String(t.priority).padEnd(priorityW) + title + "\n"
+        );
+      }
+      process.stdout.write(`
+${tasks.length} task(s) listed.
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("get <task-id>").description("Get task details and logs").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.get(taskId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`ID:           ${t.id}
+`);
+      process.stdout.write(`Title:        ${t.title}
+`);
+      process.stdout.write(`Status:       ${t.status}
+`);
+      process.stdout.write(`Priority:     ${t.priority}
+`);
+      if (t.description) process.stdout.write(`Description:  ${t.description}
+`);
+      if (t.requiredCapability) process.stdout.write(`Capability:   ${t.requiredCapability}
+`);
+      if (t.budget !== void 0) process.stdout.write(`Budget:       ${t.budget}
+`);
+      if (t.creatorId) process.stdout.write(`Creator:      ${t.creatorId}
+`);
+      if (t.assigneeId) process.stdout.write(`Assignee:     ${t.assigneeId}
+`);
+      if (t.createdAt) process.stdout.write(`Created:      ${t.createdAt}
+`);
+      if (t.updatedAt) process.stdout.write(`Updated:      ${t.updatedAt}
+`);
+      if (t.result) process.stdout.write(`Result:       ${t.result}
+`);
+      if (t.error) process.stdout.write(`Error:        ${t.error}
+`);
+      const logs = t.logs ?? t.taskLogs ?? [];
+      if (logs.length > 0) {
+        process.stdout.write(`
+Logs (${logs.length}):
+`);
+        for (const log of logs) {
+          const ts = log.createdAt ?? log.timestamp ?? "";
+          const msg = log.message ?? log.content ?? JSON.stringify(log);
+          process.stdout.write(`  [${ts}] ${msg}
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("claim <task-id>").description("Claim a pending task").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.claim(taskId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task claimed successfully
+
+`);
+      process.stdout.write(`ID:       ${t.id}
+`);
+      process.stdout.write(`Title:    ${t.title}
+`);
+      process.stdout.write(`Status:   ${t.status}
+`);
+      process.stdout.write(`Priority: ${t.priority}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("update <task-id>").description("Update a task").option("--title <title>", "new title").option("--description <description>", "new description").option("--priority <priority>", "new priority: low, normal, high, urgent").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.update(taskId, {
+        title: opts.title,
+        description: opts.description,
+        priority: opts.priority
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task updated successfully
+
+`);
+      process.stdout.write(`ID:       ${t.id}
+`);
+      process.stdout.write(`Title:    ${t.title}
+`);
+      process.stdout.write(`Status:   ${t.status}
+`);
+      process.stdout.write(`Priority: ${t.priority}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("complete <task-id>").description("Mark a task as complete").option("--result <result>", "result or output of the task").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.complete(taskId, {
+        result: opts.result
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task completed successfully
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+      if (t.result) process.stdout.write(`Result: ${t.result}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("fail <task-id>").description("Mark a task as failed").requiredOption("--error <error>", "error message describing why the task failed").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.fail(taskId, opts.error);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task marked as failed
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+      if (t.error) process.stdout.write(`Error:  ${t.error}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/memory.ts
+function register5(parent, getIMClient2, _getAPIClient) {
+  const mem = parent.command("memory").description("Agent memory file management");
+  mem.command("write").description("Write a memory file").requiredOption("-s, --scope <scope>", "memory scope").requiredOption("-p, --path <path>", "file path within scope").requiredOption("-c, --content <content>", "file content").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.createFile({
+        scope: opts.scope,
+        path: opts.path,
+        content: opts.content
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const file = res.data;
+      process.stdout.write(`Memory file created
+`);
+      process.stdout.write(`  ID:    ${file.id}
+`);
+      process.stdout.write(`  Scope: ${file.scope}
+`);
+      process.stdout.write(`  Path:  ${file.path}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("read [file-id]").description("Read a memory file by ID, or filter by scope/path").option("-s, --scope <scope>", "filter by scope (used when no file-id given)").option("-p, --path <path>", "filter by path (used when no file-id given)").option("--json", "output raw JSON response").action(async (fileId, opts) => {
+    const client = getIMClient2();
+    try {
+      if (fileId) {
+        const res = await client.im.memory.getFile(fileId);
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+          return;
+        }
+        if (!res.ok) {
+          process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+          process.exit(1);
+        }
+        const file = res.data;
+        process.stdout.write(`ID:    ${file.id}
+`);
+        process.stdout.write(`Scope: ${file.scope}
+`);
+        process.stdout.write(`Path:  ${file.path}
+`);
+        process.stdout.write(`
+${file.content ?? ""}
+`);
+        return;
+      }
+      const listRes = await client.im.memory.listFiles({
+        scope: opts.scope,
+        path: opts.path
+      });
+      if (opts.json) {
+        if (listRes.ok && Array.isArray(listRes.data) && listRes.data.length === 1) {
+          const detailRes = await client.im.memory.getFile(listRes.data[0].id);
+          process.stdout.write(JSON.stringify(detailRes, null, 2) + "\n");
+        } else {
+          process.stdout.write(JSON.stringify(listRes, null, 2) + "\n");
+        }
+        return;
+      }
+      if (!listRes.ok) {
+        process.stderr.write(`Error: ${listRes.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const files = listRes.data;
+      if (files.length === 0) {
+        process.stdout.write("No memory files found.\n");
+        return;
+      }
+      if (files.length === 1) {
+        const detailRes = await client.im.memory.getFile(files[0].id);
+        if (!detailRes.ok) {
+          process.stderr.write(`Error: ${detailRes.error?.message || "Unknown error"}
+`);
+          process.exit(1);
+        }
+        const file = detailRes.data;
+        process.stdout.write(`ID:    ${file.id}
+`);
+        process.stdout.write(`Scope: ${file.scope}
+`);
+        process.stdout.write(`Path:  ${file.path}
+`);
+        process.stdout.write(`
+${file.content ?? ""}
+`);
+        return;
+      }
+      printFileTable(files);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("list").description("List memory files").option("-s, --scope <scope>", "filter by scope").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.listFiles({ scope: opts.scope });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const files = res.data;
+      if (files.length === 0) {
+        process.stdout.write("No memory files found.\n");
+        return;
+      }
+      printFileTable(files);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("delete <file-id>").description("Delete a memory file by ID").option("--json", "output raw JSON response").action(async (fileId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.deleteFile(fileId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(`Deleted memory file: ${fileId}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("compact <conversation-id>").description("Create a compaction summary for a conversation").option("--json", "output raw JSON response").action(async (conversationId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.compact({ conversationId });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const summary = res.data;
+      process.stdout.write(`Compaction complete
+`);
+      if (summary?.id) {
+        process.stdout.write(`  Summary ID:      ${summary.id}
+`);
+      }
+      if (summary?.conversationId) {
+        process.stdout.write(`  Conversation ID: ${summary.conversationId}
+`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("load").description("Load session memory context").option("-s, --scope <scope>", "scope to load").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.load(opts.scope);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const context = res.data;
+      if (!context || typeof context === "object" && Object.keys(context).length === 0) {
+        process.stdout.write("No memory context available.\n");
+        return;
+      }
+      process.stdout.write("Memory context loaded:\n\n");
+      if (typeof context === "string") {
+        process.stdout.write(context + "\n");
+      } else {
+        process.stdout.write(JSON.stringify(context, null, 2) + "\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+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)}`;
+  process.stdout.write(row("ID", "SCOPE", "PATH") + "\n");
+  process.stdout.write(`${"-".repeat(idLen)}  ${"-".repeat(scopeLen)}  ${"-".repeat(pathLen)}
+`);
+  for (const f of files) {
+    process.stdout.write(row(f.id, f.scope, f.path) + "\n");
+  }
+}
+
+// src/commands/skill.ts
+function padEnd(str, len) {
+  if (str.length >= len) return str.slice(0, len);
+  return str + " ".repeat(len - str.length);
+}
+function formatTable(rows) {
+  if (rows.length === 0) return "";
+  const cols = rows[0].length;
+  const widths = Array(cols).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < cols; i++) {
+      widths[i] = Math.max(widths[i], (row[i] ?? "").length);
+    }
+  }
+  return rows.map((row) => row.map((cell, i) => padEnd(cell ?? "", widths[i])).join("  ")).join("\n");
+}
+function register6(parent, getIMClient2, _getAPIClient) {
+  const skill = parent.command("skill").description("Browse, install, and manage skills");
+  skill.command("find [query]").description("Search the skill marketplace").option("-c, --category <category>", "filter by category").option("-n, --limit <n>", "max results to return", "20").option("--json", "output raw JSON response").action(async (query, opts) => {
+    const client = getIMClient2();
+    try {
+      const limit = parseInt(opts.limit, 10);
+      const res = await client.im.evolution.searchSkills({
+        query,
+        category: opts.category,
+        limit
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const skills = Array.isArray(res) ? res : res?.skills ?? [];
+      if (skills.length === 0) {
+        process.stdout.write("No skills found.\n");
+        return;
+      }
+      const header = ["Slug", "Name", "Installs", "Category"];
+      const rows = skills.map((s) => {
+        const sk = s;
+        return [
+          String(sk.slug ?? sk.id ?? ""),
+          String(sk.name ?? ""),
+          String(sk.installCount ?? sk.installs ?? "0"),
+          String(sk.category ?? "")
+        ];
+      });
+      process.stdout.write(formatTable([header, ...rows]) + "\n");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("install <slug>").description("Install a skill").option("--platform <platform>", "target platform: claude-code, openclaw, opencode, or all", "all").option("--project <path>", "project directory for local file writes").option("--no-local", "cloud-only install, do not write local files").option("--json", "output raw JSON response").action(async (slug, opts) => {
+    const client = getIMClient2();
+    try {
+      let res;
+      if (!opts.local) {
+        res = await client.im.evolution.installSkill(slug);
+      } else {
+        const platforms = opts.platform === "all" ? void 0 : [opts.platform];
+        res = await client.im.evolution.installSkillLocal(slug, {
+          platforms,
+          project: opts.project
+        });
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      if (result?.ok === false) {
+        process.stderr.write(`Install failed.
+`);
+        process.exit(1);
+      }
+      const skillData = result?.data?.skill ?? {};
+      const name = String(skillData.name ?? slug);
+      process.stdout.write(`Installed: ${name}
+`);
+      const localPaths = result?.data?.localPaths ?? [];
+      if (localPaths.length > 0) {
+        process.stdout.write("Local files written:\n");
+        for (const p of localPaths) {
+          process.stdout.write(`  ${p}
+`);
+        }
+      } else if (!opts.local) {
+        process.stdout.write("Cloud-only install complete (no local files written).\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("list").description("List installed skills").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.installedSkills();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const records = Array.isArray(res) ? res : res?.skills ?? [];
+      if (records.length === 0) {
+        process.stdout.write("No skills installed.\n");
+        return;
+      }
+      const header = ["Slug", "Name", "Installs", "Category"];
+      const rows = records.map((r) => {
+        const rec = r;
+        const sk = rec.skill ?? rec;
+        return [
+          String(sk.slug ?? sk.id ?? ""),
+          String(sk.name ?? ""),
+          String(sk.installCount ?? sk.installs ?? "0"),
+          String(sk.category ?? "")
+        ];
+      });
+      process.stdout.write(formatTable([header, ...rows]) + "\n");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("show <slug>").description("Show skill content and details").option("--json", "output raw JSON response").action(async (slug, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getSkillContent(slug);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      if (result?.packageUrl) {
+        process.stdout.write(`Package URL: ${result.packageUrl}
+`);
+      }
+      if (result?.checksum) {
+        process.stdout.write(`Checksum:    ${result.checksum}
+`);
+      }
+      if (result?.files && result.files.length > 0) {
+        process.stdout.write(`Files:
+`);
+        for (const f of result.files) {
+          process.stdout.write(`  ${f}
+`);
+        }
+      }
+      if (result?.content) {
+        process.stdout.write(`
+${result.content}
+`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("uninstall <slug>").description("Uninstall a skill").option("--no-local", "cloud-only uninstall, do not remove local files").option("--json", "output raw JSON response").action(async (slug, opts) => {
+    const client = getIMClient2();
+    try {
+      let res;
+      if (!opts.local) {
+        res = await client.im.evolution.uninstallSkill(slug);
+      } else {
+        res = await client.im.evolution.uninstallSkillLocal(slug);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      if (result?.ok === false) {
+        process.stderr.write(`Uninstall failed.
+`);
+        process.exit(1);
+      }
+      process.stdout.write(`Uninstalled: ${slug}
+`);
+      const removedPaths = result?.data?.removedPaths ?? [];
+      if (removedPaths.length > 0) {
+        process.stdout.write("Local files removed:\n");
+        for (const p of removedPaths) {
+          process.stdout.write(`  ${p}
+`);
+        }
+      } else if (!opts.local) {
+        process.stdout.write("Cloud-only uninstall complete (no local files removed).\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("sync").description("Re-sync all installed skills to local filesystem").option("--platform <platform>", "target platform: claude-code, openclaw, opencode, or all", "all").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const platforms = opts.platform === "all" ? void 0 : [opts.platform];
+      const res = await client.im.evolution.syncSkillsLocal({ platforms });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      const synced = result?.synced ?? 0;
+      const failed = result?.failed ?? 0;
+      process.stdout.write(`Synced: ${synced} skill(s)`);
+      if (failed > 0) {
+        process.stdout.write(`, failed: ${failed}`);
+      }
+      process.stdout.write("\n");
+      const paths = result?.paths ?? [];
+      if (paths.length > 0) {
+        process.stdout.write("Files written:\n");
+        for (const p of paths) {
+          process.stdout.write(`  ${p}
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/files.ts
+function register7(parent, getIMClient2, _getAPIClient) {
+  const file = parent.command("file").description("File upload, transfer, quota, and type management");
+  file.command("upload <path>").description("Upload a file and get its upload ID and CDN URL").option("--mime <type>", "Override MIME type (e.g. image/png)").option("--json", "Output raw JSON response").action(async (filePath, opts) => {
+    const client = getIMClient2();
+    try {
+      const uploadOpts = {};
+      if (opts.mime) uploadOpts.mimeType = opts.mime;
+      const res = await client.im.files.upload(filePath, Object.keys(uploadOpts).length ? uploadOpts : void 0);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Uploaded: ${res.fileName}
+`);
+      process.stdout.write(`Upload ID: ${res.uploadId}
+`);
+      process.stdout.write(`CDN URL:   ${res.cdnUrl}
+`);
+      process.stdout.write(`Size:      ${res.fileSize} bytes
+`);
+      process.stdout.write(`MIME:      ${res.mimeType}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  file.command("send <conversation-id> <path>").description("Upload a file and send it as a message in a conversation").option("-c, --content <text>", "Optional text caption to accompany the file").option("--mime <type>", "Override MIME type").option("--json", "Output raw JSON response").action(async (conversationId, filePath, opts) => {
+    const client = getIMClient2();
+    try {
+      const sendOpts = {};
+      if (opts.content) sendOpts.content = opts.content;
+      if (opts.mime) sendOpts.mimeType = opts.mime;
+      const res = await client.im.files.sendFile(
+        conversationId,
+        filePath,
+        Object.keys(sendOpts).length ? sendOpts : void 0
+      );
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`File sent (messageId: ${res.message?.id || res.message?.messageId || "-"})
+`);
+      process.stdout.write(`Upload ID: ${res.upload?.uploadId || "-"}
+`);
+      process.stdout.write(`CDN URL:   ${res.upload?.cdnUrl || "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  file.command("quota").description("Show file storage quota and usage").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    const res = await client.im.files.quota();
+    if (!res.ok) {
+      process.stderr.write(`Error: ${JSON.stringify(res)}
+`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+      return;
+    }
+    const d = res.data;
+    process.stdout.write(`Tier:       ${d?.tier || "-"}
+`);
+    process.stdout.write(`Used:       ${d?.used ?? "-"} bytes
+`);
+    process.stdout.write(`Limit:      ${d?.limit ?? "-"} bytes
+`);
+    process.stdout.write(`File Count: ${d?.fileCount ?? "-"}
+`);
+  });
+  file.command("delete <upload-id>").description("Delete an uploaded file by its upload ID").action(async (uploadId) => {
+    const client = getIMClient2();
+    const res = await client.im.files.delete(uploadId);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${JSON.stringify(res)}
+`);
+      process.exit(1);
+    }
+    process.stdout.write(`File ${uploadId} deleted.
+`);
+  });
+  file.command("types").description("List allowed MIME types for file uploads").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    const res = await client.im.files.types();
+    if (!res.ok) {
+      process.stderr.write(`Error: ${JSON.stringify(res)}
+`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+      return;
+    }
+    const types = res.data?.allowedMimeTypes || [];
+    if (types.length === 0) {
+      process.stdout.write("No allowed MIME types returned.\n");
+      return;
+    }
+    process.stdout.write("Allowed MIME types:\n");
+    for (const t of types) {
+      process.stdout.write(`  ${t}
+`);
+    }
+  });
+}
+
+// src/commands/workspace.ts
+function register8(parent, getIMClient2, _getAPIClient) {
+  const workspace = parent.command("workspace").description("Workspace management \u2014 init, groups, and agent assignment");
+  workspace.command("init <name>").description("Initialize a workspace with a user and agent").requiredOption("--user-id <id>", "User ID").requiredOption("--user-name <name>", "User display name").requiredOption("--agent-id <id>", "Agent ID").requiredOption("--agent-name <name>", "Agent display name").option("--agent-type <type>", "Agent type", "assistant").option("--agent-capabilities <caps>", "Comma-separated list of agent capabilities").option("--json", "Output raw JSON response").action(async (name, opts) => {
+    const client = getIMClient2();
+    try {
+      const capabilities = opts.agentCapabilities ? opts.agentCapabilities.split(",").map((s) => s.trim()) : void 0;
+      const res = await client.im.workspace.init({
+        name,
+        userId: opts.userId,
+        userName: opts.userName,
+        agentId: opts.agentId,
+        agentName: opts.agentName,
+        agentType: opts.agentType,
+        ...capabilities !== void 0 && { agentCapabilities: capabilities }
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Workspace initialized (workspaceId: ${res.data?.workspaceId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  workspace.command("init-group <name>").description("Initialize a group workspace with a set of members").requiredOption("--members <json>", "JSON array of member objects").option("--json", "Output raw JSON response").action(async (name, opts) => {
+    const client = getIMClient2();
+    try {
+      let members;
+      try {
+        members = JSON.parse(opts.members);
+      } catch {
+        process.stderr.write("Error: --members must be a valid JSON array\n");
+        process.exit(1);
+      }
+      const res = await client.im.workspace.initGroup({ name, members });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Group workspace initialized (workspaceId: ${res.data?.workspaceId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  workspace.command("add-agent <workspace-id> <agent-id>").description("Add an agent to a workspace").option("--json", "Output raw JSON response").action(async (workspaceId, agentId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.workspace.addAgent(workspaceId, agentId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Agent ${agentId} added to workspace ${workspaceId}.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  workspace.command("agents <workspace-id>").description("List agents in a workspace").option("--json", "Output raw JSON response").action(async (workspaceId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.workspace.listAgents(workspaceId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const agents = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(agents, null, 2) + "\n");
+        return;
+      }
+      if (agents.length === 0) {
+        process.stdout.write("No agents in this workspace.\n");
+        return;
+      }
+      process.stdout.write("Agent ID".padEnd(36) + "Type".padEnd(14) + "Name\n");
+      for (const a of agents) {
+        process.stdout.write(
+          `${(a.agentId || a.id || "").padEnd(36)}${(a.agentType || "").padEnd(14)}${a.name || a.displayName || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/security.ts
+function register9(parent, getIMClient2, _getAPIClient) {
+  const security = parent.command("security").description("Per-conversation encryption and key management");
+  security.command("get <conversation-id>").description("Get security settings for a conversation").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.getConversationSecurity(convId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      process.stdout.write(`Encryption Mode: ${d?.encryptionMode ?? "-"}
+`);
+      process.stdout.write(`Signing Policy:  ${d?.signingPolicy ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("set <conversation-id>").description("Set encryption mode for a conversation").requiredOption("--mode <mode>", "Encryption mode: none, available, or required").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.setConversationSecurity(convId, {
+        encryptionMode: opts.mode
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Encryption mode set to: ${opts.mode}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("upload-key <conversation-id>").description("Upload an ECDH public key for a conversation").requiredOption("--key <base64>", "Base64-encoded public key").option("--algorithm <alg>", "Key algorithm", "ecdh-p256").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.uploadKey(convId, opts.key, opts.algorithm);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Key uploaded (algorithm: ${opts.algorithm})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("keys <conversation-id>").description("List all member public keys for a conversation").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.getKeys(convId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const keys = res.data;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(keys, null, 2) + "\n");
+        return;
+      }
+      if (!keys || Array.isArray(keys) && keys.length === 0) {
+        process.stdout.write("No keys found.\n");
+        return;
+      }
+      process.stdout.write("User ID".padEnd(36) + "Algorithm".padEnd(16) + "Public Key\n");
+      for (const k of keys) {
+        process.stdout.write(
+          `${String(k.userId ?? "").padEnd(36)}${String(k.algorithm ?? "").padEnd(16)}${String(k.publicKey ?? "")}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("revoke-key <conversation-id> <user-id>").description("Revoke a member key from a conversation").option("--json", "Output raw JSON response").action(async (convId, userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.revokeKey(convId, userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Key revoked for user: ${userId}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  const identity = parent.command("identity").description("Identity key management and audit log verification");
+  identity.command("server-key").description("Get the server's identity public key").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.getServerKey();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      process.stdout.write(`Server Public Key: ${d?.publicKey ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("register-key").description("Register an identity public key").requiredOption("--algorithm <alg>", "Key algorithm (e.g. ed25519, ecdh-p256)").requiredOption("--public-key <base64>", "Base64-encoded public key").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.registerKey({
+        algorithm: opts.algorithm,
+        publicKey: opts.publicKey
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Identity key registered (algorithm: ${opts.algorithm})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("get-key <user-id>").description("Get a user's identity public key").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.getKey(userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      process.stdout.write(`Algorithm:  ${d?.algorithm ?? "-"}
+`);
+      process.stdout.write(`Public Key: ${d?.publicKey ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("revoke-key").description("Revoke your own identity key").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.revokeKey();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write("Identity key revoked.\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("audit-log <user-id>").description("Get key audit log entries for a user").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.getAuditLog(userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const entries = res.data;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(entries, null, 2) + "\n");
+        return;
+      }
+      if (!entries || Array.isArray(entries) && entries.length === 0) {
+        process.stdout.write("No audit log entries.\n");
+        return;
+      }
+      process.stdout.write("Date".padEnd(24) + "Action".padEnd(20) + "Details\n");
+      for (const e of entries) {
+        const date = e.createdAt ? new Date(String(e.createdAt)).toLocaleString() : "";
+        process.stdout.write(
+          `${date.padEnd(24)}${String(e.action ?? "").padEnd(20)}${e.details ? JSON.stringify(e.details) : ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("verify-audit <user-id>").description("Verify the integrity of the key audit log for a user").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.verifyAuditLog(userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      if (d?.valid) {
+        process.stdout.write("Audit log verified: VALID\n");
+      } else {
+        process.stdout.write("Audit log verified: INVALID\n");
+        if (d?.errors && Array.isArray(d.errors) && d.errors.length > 0) {
+          process.stdout.write("Errors:\n");
+          for (const err of d.errors) {
+            process.stdout.write(`  - ${JSON.stringify(err)}
+`);
+          }
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      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"));
+  cliVersion = pkg.version || cliVersion;
+} catch {
+}
+var CONFIG_DIR = path.join(os.homedir(), ".prismer");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.toml");
+function ensureConfigDir() {
   if (!fs.existsSync(CONFIG_DIR)) {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
   }
 }
 function readConfig() {
-  if (!fs.existsSync(CONFIG_PATH)) {
-    return {};
-  }
+  if (!fs.existsSync(CONFIG_PATH)) return {};
   const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
   return TOML.parse(raw);
 }
 function writeConfig(config) {
   ensureConfigDir();
-  const content = TOML.stringify(config);
-  fs.writeFileSync(CONFIG_PATH, content, "utf-8");
+  fs.writeFileSync(CONFIG_PATH, TOML.stringify(config), { encoding: "utf-8", mode: 384 });
 }
 function setNestedValue(obj, dotPath, value) {
   const parts = dotPath.split(".");
   let current = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const key = parts[i];
-    if (current[key] === void 0 || typeof current[key] !== "object") {
-      current[key] = {};
-    }
+    if (current[key] === void 0 || typeof current[key] !== "object") current[key] = {};
     current = current[key];
   }
   current[parts[parts.length - 1]] = value;
@@ -1776,7 +5003,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";
@@ -1787,35 +5014,200 @@ 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";
   const baseUrl = cfg?.default?.base_url || "";
   return new PrismerClient({ apiKey, environment: env, ...baseUrl ? { baseUrl } : {} });
 }
-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();
-  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");
+var program = new import_commander.Command();
+program.name("prismer").description("Prismer Cloud SDK CLI").version(cliVersion);
+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";
+  writeConfig(config);
+  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.");
+}
+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 http = require("http");
+  const crypto2 = require("crypto");
+  const state = crypto2.randomBytes(16).toString("hex");
+  let resolved = false;
+  const server = http.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("register <username>").description("Register an IM agent and store the token").option("--type <type>", "Identity type: agent or human", "agent").option("--display-name <name>", "Display name for the agent").option("--agent-type <agentType>", "Agent type: assistant, specialist, orchestrator, tool, or bot").option("--capabilities <caps>", "Comma-separated list of capabilities").action(async (username, opts) => {
+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('Error: No API key configured. Run "prismer init <api-key>" first.');
+    console.error('No API key. Run "prismer setup" first.');
     process.exit(1);
   }
   const client = new PrismerClient({
@@ -1828,12 +5220,10 @@ program.command("register <username>").description("Register an IM agent and sto
     username,
     displayName: opts.displayName || username
   };
-  if (opts.agentType) {
-    registerOpts.agentType = opts.agentType;
-  }
-  if (opts.capabilities) {
-    registerOpts.capabilities = opts.capabilities.split(",").map((c) => c.trim());
-  }
+  if (opts.agentType) registerOpts.agentType = opts.agentType;
+  if (opts.capabilities) registerOpts.capabilities = opts.capabilities.split(",").map((c) => c.trim());
+  if (opts.endpoint) registerOpts.endpoint = opts.endpoint;
+  if (opts.webhookSecret) registerOpts.webhookSecret = opts.webhookSecret;
   try {
     const result = await client.im.account.register(registerOpts);
     if (!result.ok || !result.data) {
@@ -1841,9 +5231,7 @@ program.command("register <username>").description("Register an IM agent and sto
       process.exit(1);
     }
     const data = result.data;
-    if (!config.auth) {
-      config.auth = {};
-    }
+    if (!config.auth) config.auth = {};
     config.auth.im_token = data.token;
     config.auth.im_user_id = data.imUserId;
     config.auth.im_username = data.username;
@@ -1855,18 +5243,15 @@ program.command("register <username>").description("Register an IM agent and sto
     console.log(`  Display:  ${data.displayName}`);
     console.log(`  Role:     ${data.role}`);
     console.log(`  New:      ${data.isNew}`);
-    console.log(`  Expires:  ${data.expiresIn}`);
-    console.log("");
     console.log("Token stored in ~/.prismer/config.toml");
   } catch (err) {
     console.error("Registration failed:", err instanceof Error ? err.message : err);
     process.exit(1);
   }
 });
-program.command("status").description("Show current config and token status").action(async () => {
+program.command("status").description("Show current config and live info").action(async () => {
   const config = readConfig();
-  console.log("=== Prismer Status ===");
-  console.log("");
+  console.log("=== Prismer Status ===\n");
   const apiKey = config.default?.api_key;
   if (apiKey) {
     const masked = apiKey.length > 16 ? apiKey.slice(0, 12) + "..." + apiKey.slice(-4) : "***";
@@ -1875,8 +5260,8 @@ program.command("status").description("Show current config and token status").ac
     console.log("API Key:     (not set)");
   }
   console.log(`Environment: ${config.default?.environment || "(not set)"}`);
-  console.log(`Base URL:    ${config.default?.base_url || "(default)"}`);
-  console.log("");
+  console.log(`Base URL:    ${config.default?.base_url || "(default)"}
+`);
   const token = config.auth?.im_token;
   if (token) {
     console.log(`IM User ID:  ${config.auth?.im_user_id || "(unknown)"}`);
@@ -1885,9 +5270,7 @@ program.command("status").description("Show current config and token status").ac
     if (expires) {
       const expiresDate = new Date(expires);
       if (!isNaN(expiresDate.getTime())) {
-        const now = /* @__PURE__ */ new Date();
-        const isExpired = expiresDate <= now;
-        const label = isExpired ? "EXPIRED" : "valid";
+        const label = expiresDate <= /* @__PURE__ */ new Date() ? "EXPIRED" : "valid";
         console.log(`IM Token:    ${label} (expires ${expiresDate.toISOString()})`);
       } else {
         console.log(`IM Token:    set (expires in ${expires})`);
@@ -1895,12 +5278,7 @@ program.command("status").description("Show current config and token status").ac
     } else {
       console.log("IM Token:    set (expiry unknown)");
     }
-  } else {
-    console.log("IM Token:    (not registered)");
-  }
-  if (token) {
-    console.log("");
-    console.log("--- Live Info ---");
+    console.log("\n--- Live Info ---");
     try {
       const client = new PrismerClient({
         apiKey: token,
@@ -1920,355 +5298,79 @@ program.command("status").description("Show current config and token status").ac
     } catch (err) {
       console.log(`Could not fetch live info: ${err instanceof Error ? err.message : err}`);
     }
+  } else {
+    console.log("IM Token:    (not registered)");
   }
 });
 var configCmd = program.command("config").description("Manage config file");
-configCmd.command("show").description("Print config file contents").action(() => {
+configCmd.command("show").description("Print config file").action(() => {
   if (!fs.existsSync(CONFIG_PATH)) {
-    console.log("No config file found at ~/.prismer/config.toml");
-    console.log('Run "prismer init <api-key>" to create one.');
+    console.log('No config file. Run "prismer setup" to create one.');
     return;
   }
-  const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
-  console.log(raw);
+  console.log(fs.readFileSync(CONFIG_PATH, "utf-8"));
 });
-configCmd.command("set <key> <value>").description("Set a config value (e.g., prismer config set default.api_key sk-prismer-...)").action((key, value) => {
+configCmd.command("set <key> <value>").description("Set a config value (e.g. default.base_url)").action((key, value) => {
   const config = readConfig();
   setNestedValue(config, key, value);
   writeConfig(config);
   console.log(`Set ${key} = ${value}`);
 });
-var im = program.command("im").description("IM messaging commands");
-im.command("me").description("Show current identity and stats").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const res = await client.im.account.me();
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const d = res.data;
-  if (opts.json) {
-    console.log(JSON.stringify(d, null, 2));
-    return;
-  }
-  console.log(`Display Name: ${d?.user?.displayName || "-"}`);
-  console.log(`Username:     ${d?.user?.username || "-"}`);
-  console.log(`Role:         ${d?.user?.role || "-"}`);
-  console.log(`Agent Type:   ${d?.agentCard?.agentType || "-"}`);
-  console.log(`Credits:      ${d?.credits?.balance ?? "-"}`);
-  console.log(`Messages:     ${d?.stats?.messagesSent ?? "-"}`);
-  console.log(`Unread:       ${d?.stats?.unreadCount ?? "-"}`);
-});
-im.command("health").description("Check IM service health").action(async () => {
-  const client = getIMClient();
-  const res = await client.im.health();
-  console.log(`IM Service: ${res.ok ? "OK" : "ERROR"}`);
-  if (!res.ok) {
-    console.error(res.error);
-    process.exit(1);
-  }
-});
-im.command("send").description("Send a direct message").argument("<user-id>", "Target user ID").argument("<message>", "Message content").option("--json", "JSON output").action(async (userId, message, opts) => {
-  const client = getIMClient();
-  const res = await client.im.direct.send(userId, message);
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(res.data, null, 2));
-    return;
-  }
-  console.log(`Message sent (conversationId: ${res.data?.conversationId})`);
-});
-im.command("messages").description("View direct message history").argument("<user-id>", "Target user ID").option("-n, --limit <n>", "Max messages", "20").option("--json", "JSON output").action(async (userId, opts) => {
-  const client = getIMClient();
-  const res = await client.im.direct.getMessages(userId, { limit: parseInt(opts.limit) });
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const msgs = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(msgs, null, 2));
-    return;
-  }
-  if (msgs.length === 0) {
-    console.log("No messages.");
-    return;
-  }
-  for (const m of msgs) {
-    const ts = m.createdAt ? new Date(m.createdAt).toLocaleString() : "";
-    console.log(`[${ts}] ${m.senderId || "?"}: ${m.content}`);
-  }
-});
-im.command("discover").description("Discover available agents").option("--type <type>", "Filter by type").option("--capability <cap>", "Filter by capability").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const discoverOpts = {};
-  if (opts.type) discoverOpts.type = opts.type;
-  if (opts.capability) discoverOpts.capability = opts.capability;
-  const res = await client.im.contacts.discover(discoverOpts);
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const agents = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(agents, null, 2));
-    return;
-  }
-  if (agents.length === 0) {
-    console.log("No agents found.");
-    return;
-  }
-  console.log("Username".padEnd(20) + "Type".padEnd(14) + "Status".padEnd(10) + "Display Name");
-  for (const a of agents) {
-    console.log(`${(a.username || "").padEnd(20)}${(a.agentType || "").padEnd(14)}${(a.status || "").padEnd(10)}${a.displayName || ""}`);
-  }
-});
-im.command("contacts").description("List contacts").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const res = await client.im.contacts.list();
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const contacts = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(contacts, null, 2));
-    return;
-  }
-  if (contacts.length === 0) {
-    console.log("No contacts.");
-    return;
-  }
-  console.log("Username".padEnd(20) + "Role".padEnd(10) + "Unread".padEnd(8) + "Display Name");
-  for (const c of contacts) {
-    console.log(`${(c.username || "").padEnd(20)}${(c.role || "").padEnd(10)}${String(c.unreadCount ?? 0).padEnd(8)}${c.displayName || ""}`);
-  }
-});
-var groups = im.command("groups").description("Group management");
-groups.command("list").description("List groups").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const res = await client.im.groups.list();
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const list = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(list, null, 2));
-    return;
-  }
-  if (list.length === 0) {
-    console.log("No groups.");
-    return;
-  }
-  for (const g of list) {
-    console.log(`${g.groupId || ""}  ${g.title || ""} (${g.members?.length || "?"} members)`);
-  }
-});
-groups.command("create").description("Create a group").argument("<title>", "Group title").option("-m, --members <ids>", "Comma-separated member IDs").option("--json", "JSON output").action(async (title, opts) => {
-  const client = getIMClient();
-  const members = opts.members ? opts.members.split(",").map((s) => s.trim()) : [];
-  const res = await client.im.groups.create({ title, members });
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(res.data, null, 2));
-    return;
-  }
-  console.log(`Group created (groupId: ${res.data?.groupId})`);
-});
-groups.command("send").description("Send message to group").argument("<group-id>", "Group ID").argument("<message>", "Message content").option("--json", "JSON output").action(async (groupId, message, opts) => {
-  const client = getIMClient();
-  const res = await client.im.groups.send(groupId, message);
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  if (opts.json) {
-    console.log(JSON.stringify(res.data, null, 2));
-    return;
-  }
-  console.log("Message sent to group.");
-});
-groups.command("messages").description("View group message history").argument("<group-id>", "Group ID").option("-n, --limit <n>", "Max messages", "20").option("--json", "JSON output").action(async (groupId, opts) => {
-  const client = getIMClient();
-  const res = await client.im.groups.getMessages(groupId, { limit: parseInt(opts.limit) });
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const msgs = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(msgs, null, 2));
-    return;
-  }
-  if (msgs.length === 0) {
-    console.log("No messages.");
-    return;
-  }
-  for (const m of msgs) {
-    const ts = m.createdAt ? new Date(m.createdAt).toLocaleString() : "";
-    console.log(`[${ts}] ${m.senderId || "?"}: ${m.content}`);
-  }
-});
-var convos = im.command("conversations").description("Conversation management");
-convos.command("list").description("List conversations").option("--unread", "Show unread only").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const listOpts = {};
-  if (opts.unread) {
-    listOpts.withUnread = true;
-    listOpts.unreadOnly = true;
-  }
-  const res = await client.im.conversations.list(listOpts);
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  const list = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(list, null, 2));
-    return;
-  }
-  if (list.length === 0) {
-    console.log("No conversations.");
-    return;
-  }
-  for (const c of list) {
-    const unread = c.unreadCount ? ` (${c.unreadCount} unread)` : "";
-    console.log(`${c.id || ""}  ${c.type || ""}  ${c.title || ""}${unread}`);
-  }
-});
-convos.command("read").description("Mark conversation as read").argument("<conversation-id>", "Conversation ID").action(async (convId) => {
-  const client = getIMClient();
-  const res = await client.im.conversations.markAsRead(convId);
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  console.log("Marked as read.");
-});
-var files = im.command("files").description("File upload management");
-files.command("upload").description("Upload a file").argument("<path>", "File path to upload").option("--mime <type>", "Override MIME type").option("--json", "JSON output").action(async (filePath, opts) => {
-  const client = getIMClient();
-  try {
-    const result = await client.im.files.upload(filePath, { mimeType: opts.mime });
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    console.log(`Upload ID: ${result.uploadId}`);
-    console.log(`CDN URL:   ${result.cdnUrl}`);
-    console.log(`File:      ${result.fileName} (${result.fileSize} bytes)`);
-    console.log(`MIME:      ${result.mimeType}`);
-  } catch (err) {
-    console.error("Upload failed:", err instanceof Error ? err.message : err);
-    process.exit(1);
-  }
-});
-files.command("send").description("Upload file and send as message").argument("<conversation-id>", "Conversation ID").argument("<path>", "File path to upload").option("--content <text>", "Message text").option("--mime <type>", "Override MIME type").option("--json", "JSON output").action(async (conversationId, filePath, opts) => {
-  const client = getIMClient();
-  try {
-    const result = await client.im.files.sendFile(conversationId, filePath, { content: opts.content, mimeType: opts.mime });
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    console.log(`Upload ID: ${result.upload.uploadId}`);
-    console.log(`CDN URL:   ${result.upload.cdnUrl}`);
-    console.log(`File:      ${result.upload.fileName}`);
-    console.log(`Message:   sent`);
-  } catch (err) {
-    console.error("Send file failed:", err instanceof Error ? err.message : err);
-    process.exit(1);
-  }
-});
-files.command("quota").description("Show storage quota").option("--json", "JSON output").action(async (opts) => {
+var tokenCmd = program.command("token").description("Token management");
+tokenCmd.command("refresh").description("Refresh IM JWT token").option("--json", "JSON output").action(async (opts) => {
   const client = getIMClient();
-  const res = await client.im.files.quota();
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
+  const res = await client.im.account.refreshToken();
   if (opts.json) {
-    console.log(JSON.stringify(res.data, null, 2));
+    console.log(JSON.stringify(res, null, 2));
     return;
   }
-  const q = res.data;
-  console.log(`Used:       ${q?.used ?? "-"} bytes`);
-  console.log(`Limit:      ${q?.limit ?? "-"} bytes`);
-  console.log(`File Count: ${q?.fileCount ?? "-"}`);
-  console.log(`Tier:       ${q?.tier ?? "-"}`);
-});
-files.command("delete").description("Delete an uploaded file").argument("<upload-id>", "Upload ID").action(async (uploadId) => {
-  const client = getIMClient();
-  const res = await client.im.files.delete(uploadId);
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
-  console.log(`Deleted upload ${uploadId}.`);
-});
-files.command("types").description("List allowed MIME types").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const res = await client.im.files.types();
   if (!res.ok) {
     console.error("Error:", res.error);
     process.exit(1);
   }
-  if (opts.json) {
-    console.log(JSON.stringify(res.data, null, 2));
-    return;
-  }
-  const types = res.data?.allowedMimeTypes || [];
-  console.log(`Allowed MIME types (${types.length}):`);
-  for (const t of types) {
-    console.log(`  ${t}`);
+  const data = res.data;
+  const config = readConfig();
+  if (!config.auth) config.auth = {};
+  if (data?.token) {
+    config.auth.im_token = data.token;
+    if (data.expiresIn) config.auth.im_token_expires = data.expiresIn;
+    writeConfig(config);
+    console.log("Token refreshed and saved.");
+  } else {
+    console.log("Token refreshed (no new token in response).");
   }
 });
-im.command("credits").description("Show credits balance").option("--json", "JSON output").action(async (opts) => {
+register(program, getIMClient, getAPIClient);
+register2(program, getIMClient, getAPIClient);
+register3(program, getIMClient, getAPIClient);
+register4(program, getIMClient, getAPIClient);
+register5(program, getIMClient, getAPIClient);
+register6(program, getIMClient, getAPIClient);
+register7(program, getIMClient, getAPIClient);
+register8(program, getIMClient, getAPIClient);
+register9(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 res = await client.im.credits.get();
-  if (!res.ok) {
-    console.error("Error:", res.error);
-    process.exit(1);
-  }
+  const sendOpts = {};
+  if (opts.type && opts.type !== "text") sendOpts.type = opts.type;
+  if (opts.replyTo) sendOpts.parentId = opts.replyTo;
+  const res = await client.im.direct.send(userId, message, sendOpts);
   if (opts.json) {
-    console.log(JSON.stringify(res.data, null, 2));
+    console.log(JSON.stringify(res, null, 2));
     return;
   }
-  console.log(`Balance: ${res.data?.balance ?? "-"}`);
-});
-im.command("transactions").description("Transaction history").option("-n, --limit <n>", "Max transactions", "20").option("--json", "JSON output").action(async (opts) => {
-  const client = getIMClient();
-  const res = await client.im.credits.transactions({ limit: parseInt(opts.limit) });
   if (!res.ok) {
     console.error("Error:", res.error);
     process.exit(1);
   }
-  const txns = res.data || [];
-  if (opts.json) {
-    console.log(JSON.stringify(txns, null, 2));
-    return;
-  }
-  if (txns.length === 0) {
-    console.log("No transactions.");
-    return;
-  }
-  for (const t of txns) {
-    console.log(`${t.createdAt || ""}  ${t.type || ""}  ${t.amount ?? ""}  ${t.description || ""}`);
-  }
+  console.log(`Message sent (conversation: ${res.data?.conversationId})`);
 });
-var ctx = program.command("context").description("Context API commands");
-ctx.command("load").description("Load URL content").argument("<url>", "URL to load").option("-f, --format <fmt>", "Return format: hqcc, raw, both", "hqcc").option("--json", "JSON output").action(async (url, opts) => {
+program.command("load").description("Load URL(s) \u2192 compressed HQCC (shortcut for: context load)").argument("<urls...>", "One or more URLs").option("-f, --format <fmt>", "Return format: hqcc, raw, both", "hqcc").option("--json", "JSON output").action(async (urls, opts) => {
   const client = getAPIClient();
+  const input = urls.length === 1 ? urls[0] : urls;
   const loadOpts = {};
   if (opts.format) loadOpts.return = { format: opts.format };
-  const res = await client.load(url, loadOpts);
+  const res = await client.load(input, loadOpts);
   if (opts.json) {
     console.log(JSON.stringify(res, null, 2));
     return;
@@ -2277,23 +5379,22 @@ ctx.command("load").description("Load URL content").argument("<url>", "URL to lo
     console.error("Error:", res.error?.message || "Load failed");
     process.exit(1);
   }
-  const r = res.result;
-  console.log(`URL:     ${r?.url || url}`);
-  console.log(`Status:  ${r?.cached ? "cached" : "loaded"}`);
-  if (r?.hqcc) {
-    console.log(`
+  const results = res.results || (res.result ? [res.result] : []);
+  for (const r of results) {
+    console.log(`URL:    ${r.url || "?"}`);
+    console.log(`Status: ${r.cached ? "cached" : "loaded"}`);
+    if (r.hqcc) console.log(`
 --- HQCC ---
 ${r.hqcc.substring(0, 2e3)}`);
-  }
-  if (r?.raw) {
-    console.log(`
+    if (r.raw) console.log(`
 --- Raw ---
 ${r.raw.substring(0, 2e3)}`);
+    console.log("");
   }
 });
-ctx.command("search").description("Search cached content").argument("<query>", "Search query").option("-k, --top-k <n>", "Number of results", "5").option("--json", "JSON output").action(async (query, opts) => {
+program.command("search").description("Search web content (shortcut for: context search)").argument("<query>", "Search query").option("-k, --top-k <n>", "Number of results", "5").option("--json", "JSON output").action(async (query, opts) => {
   const client = getAPIClient();
-  const res = await client.search(query, { topK: parseInt(opts.topK) });
+  const res = await client.search(query, { topK: parseInt(opts.topK || "5") });
   if (opts.json) {
     console.log(JSON.stringify(res, null, 2));
     return;
@@ -2313,21 +5414,7 @@ ctx.command("search").description("Search cached content").argument("<query>", "
     if (r.hqcc) console.log(`   ${r.hqcc.substring(0, 200)}`);
   }
 });
-ctx.command("save").description("Save content to cache").argument("<url>", "URL key").argument("<hqcc>", "HQCC content").option("--json", "JSON output").action(async (url, hqcc, opts) => {
-  const client = getAPIClient();
-  const res = await client.save({ url, hqcc });
-  if (opts.json) {
-    console.log(JSON.stringify(res, null, 2));
-    return;
-  }
-  if (!res.success) {
-    console.error("Error:", res.error?.message || "Save failed");
-    process.exit(1);
-  }
-  console.log("Content saved.");
-});
-var parse2 = program.command("parse").description("Document parsing commands");
-parse2.command("run").description("Parse a document").argument("<url>", "Document URL").option("-m, --mode <mode>", "Parse mode: fast, hires, auto", "fast").option("--json", "JSON output").action(async (url, opts) => {
+program.command("parse").description("Parse a document via OCR (shortcut for: parse run)").argument("<url>", "Document URL").option("-m, --mode <mode>", "Parse mode: fast, hires, auto", "fast").option("--async", "Async mode (returns task ID)").option("--json", "JSON output").action(async (url, opts) => {
   const client = getAPIClient();
   const res = await client.parsePdf(url, opts.mode);
   if (opts.json) {
@@ -2342,14 +5429,17 @@ parse2.command("run").description("Parse a document").argument("<url>", "Documen
     console.log(`Task ID: ${res.taskId}`);
     console.log(`Status:  ${res.status || "processing"}`);
     console.log(`
-Check progress: prismer parse status ${res.taskId}`);
+Check: prismer parse status ${res.taskId}`);
   } else if (res.document) {
-    console.log(`Status: complete`);
+    console.log("Status: complete");
     const content = res.document.markdown || res.document.text || JSON.stringify(res.document, null, 2);
     console.log(content.substring(0, 5e3));
   }
 });
-parse2.command("status").description("Check parse task status").argument("<task-id>", "Task ID").option("--json", "JSON output").action(async (taskId, opts) => {
+var parseCmd = program.commands.find((c) => c.name() === "parse");
+if (parseCmd) {
+}
+program.command("parse-status").description("Check parse task status").argument("<task-id>", "Task ID").option("--json", "JSON output").action(async (taskId, opts) => {
   const client = getAPIClient();
   const res = await client.parseStatus(taskId);
   if (opts.json) {
@@ -2359,7 +5449,7 @@ parse2.command("status").description("Check parse task status").argument("<task-
   console.log(`Task:   ${taskId}`);
   console.log(`Status: ${res.status || (res.success ? "complete" : "unknown")}`);
 });
-parse2.command("result").description("Get parse result").argument("<task-id>", "Task ID").option("--json", "JSON output").action(async (taskId, opts) => {
+program.command("parse-result").description("Get parse result").argument("<task-id>", "Task ID").option("--json", "JSON output").action(async (taskId, opts) => {
   const client = getAPIClient();
   const res = await client.parseResult(taskId);
   if (opts.json) {
@@ -2373,4 +5463,57 @@ parse2.command("result").description("Get parse result").argument("<task-id>", "
   const content = res.document?.markdown || res.document?.text || JSON.stringify(res.document, null, 2);
   console.log(content);
 });
+program.command("recall").description("Search across memory, cache, and evolution (shortcut for: memory recall)").argument("<query>", "Search query").option("--scope <scope>", "Scope: all, memory, cache, evolution", "all").option("-n, --limit <n>", "Max results", "10").option("--json", "JSON output").action(async (query, opts) => {
+  const client = getIMClient();
+  const params = { q: query };
+  if (opts.scope) params.scope = opts.scope;
+  if (opts.limit) params.limit = opts.limit;
+  const res = await client.im.memory._r("GET", "/api/im/recall", void 0, params);
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    console.error("Error:", res.error);
+    process.exit(1);
+  }
+  const data = res.data || [];
+  if (data.length === 0) {
+    console.log(`No results for "${query}".`);
+    return;
+  }
+  for (const item of data) {
+    console.log(`[${(item.source || "").toUpperCase()}] ${item.title || "?"}  (score: ${(item.score || 0).toFixed(2)})`);
+    if (item.snippet) console.log(`  ${item.snippet.substring(0, 200)}`);
+  }
+});
+program.command("discover").description("Discover available agents (shortcut for: im discover)").option("--type <type>", "Filter by agent type").option("--capability <cap>", "Filter by capability").option("--json", "JSON output").action(async (opts) => {
+  const client = getIMClient();
+  const discoverOpts = {};
+  if (opts.type) discoverOpts.type = opts.type;
+  if (opts.capability) discoverOpts.capability = opts.capability;
+  const res = await client.im.contacts.discover(discoverOpts);
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    console.error("Error:", res.error);
+    process.exit(1);
+  }
+  const agents = res.data || [];
+  if (agents.length === 0) {
+    console.log("No agents found.");
+    return;
+  }
+  console.log("Username".padEnd(20) + "Type".padEnd(14) + "Status".padEnd(10) + "Display Name");
+  for (const a of agents) {
+    console.log(`${(a.username || "").padEnd(20)}${(a.agentType || "").padEnd(14)}${(a.status || "").padEnd(10)}${a.displayName || ""}`);
+  }
+});
 program.parse(process.argv);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAPIClient,
+  getIMClient
+});