@prismer/sdk 1.9.22 → 2.0.0

package/dist/cli.js

@@ -36,8 +36,8 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var import_commander = require("commander");
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var TOML2 = __toESM(require("@iarna/toml"));
 
@@ -163,7 +163,7 @@ var RealtimeWSClient = class extends TypedEmitter {
     if (this._state === "connected" || this._state === "connecting") return;
     this._state = "connecting";
     this.intentionalClose = false;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       try {
         this.ws = new this.WS(this.wsUrl);
       } catch (err) {
@@ -185,7 +185,7 @@ var RealtimeWSClient = class extends TypedEmitter {
             this.emit("connected", void 0);
             this.ws.removeEventListener("message", onFirstMessage);
             this.ws.addEventListener("message", this.handleMessage);
-            resolve2();
+            resolve3();
           }
         } catch (_) {
         }
@@ -257,12 +257,12 @@ var RealtimeWSClient = class extends TypedEmitter {
   }
   ping() {
     const requestId = `ping-${++this.pingCounter}`;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pendingPings.delete(requestId);
         reject(new Error("Ping timeout"));
       }, 1e4);
-      this.pendingPings.set(requestId, { resolve: resolve2, timer });
+      this.pendingPings.set(requestId, { resolve: resolve3, timer });
       this.sendRaw({ type: "ping", payload: { requestId } });
     });
   }
@@ -515,9 +515,9 @@ var WRITE_PATTERNS = [
   { method: "POST", pattern: /\/api\/im\/community\/posts\/[^/]+\/comments$/, opType: "community_comment" },
   { method: "POST", pattern: /\/api\/im\/community\/vote$/, opType: "community_vote" }
 ];
-function matchWriteOp(method, path4) {
+function matchWriteOp(method, path5) {
   for (const { method: m, pattern, opType } of WRITE_PATTERNS) {
-    if (method === m && pattern.test(path4)) return opType;
+    if (method === m && pattern.test(path5)) return opType;
   }
   return null;
 }
@@ -585,18 +585,18 @@ var OfflineManager = class extends OfflineEmitter {
   /**
    * Dispatch an IM request. Write ops go through outbox; reads check local cache.
    */
-  async dispatch(method, path4, body, query) {
-    const opType = matchWriteOp(method, path4);
+  async dispatch(method, path5, body, query) {
+    const opType = matchWriteOp(method, path5);
     if (opType) {
-      return this.dispatchWrite(opType, method, path4, body, query);
+      return this.dispatchWrite(opType, method, path5, body, query);
     }
     if (method === "GET") {
-      const cached = await this.readFromCache(path4, query);
+      const cached = await this.readFromCache(path5, query);
       if (cached !== null) return cached;
     }
     try {
-      const result = await this.networkRequest(method, path4, body, query);
-      if (method === "GET") this.cacheReadResult(path4, query, result);
+      const result = await this.networkRequest(method, path5, body, query);
+      if (method === "GET") this.cacheReadResult(path5, query, result);
       return result;
     } catch {
       if (!this._isOnline) {
@@ -606,7 +606,7 @@ var OfflineManager = class extends OfflineEmitter {
     }
   }
   // ── Outbox: write operations ──────────────────────────────
-  async dispatchWrite(opType, method, path4, body, query) {
+  async dispatchWrite(opType, method, path5, body, query) {
     const clientId = generateId();
     const idempotencyKey = `sdk-${clientId}`;
     let enrichedBody = body;
@@ -620,7 +620,7 @@ var OfflineManager = class extends OfflineEmitter {
     let localMessage;
     if (opType === "message.send" && body && typeof body === "object") {
       const b = body;
-      const convIdMatch = path4.match(/\/(?:messages|direct|groups)\/([^/]+)/);
+      const convIdMatch = path5.match(/\/(?:messages|direct|groups)\/([^/]+)/);
       const conversationId = convIdMatch?.[1] ?? "";
       localMessage = {
         id: `local-${clientId}`,
@@ -641,7 +641,7 @@ var OfflineManager = class extends OfflineEmitter {
       id: clientId,
       type: opType,
       method,
-      path: path4,
+      path: path5,
       body: enrichedBody,
       query,
       status: "pending",
@@ -961,28 +961,28 @@ var OfflineManager = class extends OfflineEmitter {
     return 0;
   }
   // ── Read cache ────────────────────────────────────────────
-  async readFromCache(path4, query) {
-    if (/\/api\/im\/conversations$/.test(path4)) {
+  async readFromCache(path5, query) {
+    if (/\/api\/im\/conversations$/.test(path5)) {
       const convos = await this.storage.getConversations({ limit: 50 });
       if (convos.length > 0) return { ok: true, data: convos };
     }
-    const msgMatch = path4.match(/\/api\/im\/messages\/([^/]+)$/);
+    const msgMatch = path5.match(/\/api\/im\/messages\/([^/]+)$/);
     if (msgMatch) {
       const convId = msgMatch[1];
       const limit = query?.limit ? parseInt(query.limit) : 50;
       const messages = await this.storage.getMessages(convId, { limit, before: query?.before });
       if (messages.length > 0) return { ok: true, data: messages };
     }
-    if (/\/api\/im\/contacts$/.test(path4)) {
+    if (/\/api\/im\/contacts$/.test(path5)) {
       const contacts = await this.storage.getContacts();
       if (contacts.length > 0) return { ok: true, data: contacts };
     }
     return null;
   }
-  async cacheReadResult(path4, _query, result) {
+  async cacheReadResult(path5, _query, result) {
     if (!result?.ok || !result?.data) return;
     try {
-      if (/\/api\/im\/conversations$/.test(path4) && Array.isArray(result.data)) {
+      if (/\/api\/im\/conversations$/.test(path5) && Array.isArray(result.data)) {
         const convos = result.data.map((c) => ({
           id: c.id,
           type: c.type ?? "direct",
@@ -996,7 +996,7 @@ var OfflineManager = class extends OfflineEmitter {
         }));
         await this.storage.putConversations(convos);
       }
-      const msgMatch = path4.match(/\/api\/im\/messages\/([^/]+)$/);
+      const msgMatch = path5.match(/\/api\/im\/messages\/([^/]+)$/);
       if (msgMatch && Array.isArray(result.data)) {
         const messages = result.data.map((m) => ({
           id: m.id,
@@ -1011,7 +1011,7 @@ var OfflineManager = class extends OfflineEmitter {
         }));
         await this.storage.putMessages(messages);
       }
-      if (/\/api\/im\/contacts$/.test(path4) && Array.isArray(result.data)) {
+      if (/\/api\/im\/contacts$/.test(path5) && Array.isArray(result.data)) {
         await this.storage.putContacts(result.data);
       }
     } catch {
@@ -1801,6 +1801,7 @@ var DirectClient = class {
       content,
       type: options?.type ?? "text",
       metadata: options?.metadata,
+      attachments: options?.attachments,
       parentId: options?.parentId,
       quotedMessageId: options?.quotedMessageId
     });
@@ -1835,6 +1836,7 @@ var GroupsClient = class {
       content,
       type: options?.type ?? "text",
       metadata: options?.metadata,
+      attachments: options?.attachments,
       parentId: options?.parentId,
       quotedMessageId: options?.quotedMessageId
     });
@@ -1913,6 +1915,7 @@ var MessagesClient = class {
       content,
       type: options?.type ?? "text",
       metadata: options?.metadata,
+      attachments: options?.attachments,
       parentId: options?.parentId,
       quotedMessageId: options?.quotedMessageId
     });
@@ -1973,6 +1976,11 @@ var ContactsClient = class {
     const query = {};
     if (options?.type) query.type = options.type;
     if (options?.capability) query.capability = options.capability;
+    if (options?.status) query.status = options.status;
+    if (options?.onlineOnly) query.onlineOnly = options.onlineOnly;
+    if (options?.q) query.q = options.q;
+    if (options?.limit) query.limit = options.limit;
+    if (options?.offset) query.offset = options.offset;
     return this._r("GET", "/api/im/discover", void 0, query);
   }
   // ─── Friend System (v1.8.0 P9) ─────────────────────────
@@ -2171,8 +2179,8 @@ var TasksClient = class {
     return this._r("POST", `/api/im/tasks/${taskId}/complete`, options);
   }
   /** Fail a task with error */
-  async fail(taskId, error2, metadata) {
-    return this._r("POST", `/api/im/tasks/${taskId}/fail`, { error: error2, metadata });
+  async fail(taskId, error, metadata) {
+    return this._r("POST", `/api/im/tasks/${taskId}/fail`, { error, metadata });
   }
   /** Approve a completed task */
   async approve(taskId) {
@@ -2186,6 +2194,32 @@ var TasksClient = class {
   async cancel(taskId) {
     return this._r("DELETE", `/api/im/tasks/${taskId}`);
   }
+  /**
+   * v2.0 release 200 §6.1 — unified state-machine transition.
+   *
+   * Drives every kanban / approve / reject / cancel / blocked / retry /
+   * restore action through one endpoint. The 5 legacy endpoints
+   * (start/complete/approve/reject/cancel) remain for backward
+   * compatibility but new integrations should prefer this entrypoint.
+   *
+   * Server responds 409 (`code: 'invalid-transition'`) if the requested
+   * `to` is not in the TRANSITIONS matrix from the current status, or
+   * 403 (`code: 'forbidden'`) if the actor's tier is not in the rule's
+   * `allowedActors`.
+   */
+  async transition(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/transition`, options);
+  }
+  /**
+   * v2.0 release 200 §5.3 — admin escape-hatch.
+   *
+   * Bypasses the TRANSITIONS matrix. Restricted to workspace owner /
+   * admin / trustTier>=4. Reason is required; the call is audit-logged
+   * with `force_transition: true`. UI does NOT expose this — ops only.
+   */
+  async forceTransition(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/force-transition`, options);
+  }
 };
 var MemoryClient = class {
   constructor(_r) {
@@ -2314,9 +2348,118 @@ var SecurityClient = class {
     return this._r("DELETE", `/api/im/conversations/${conversationId}/keys/${keyUserId}`);
   }
 };
+var EvolutionSkillsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List the skill catalog. Alias of search() for the v2.0 public surface. */
+  async list(options) {
+    return this.search(options);
+  }
+  /** Browse and search the skill catalog. */
+  async search(options) {
+    const query = {};
+    if (options?.query) query.query = options.query;
+    if (options?.category) query.category = options.category;
+    if (options?.source) query.source = options.source;
+    if (options?.compatibility) query.compatibility = options.compatibility;
+    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/skills/search", void 0, query);
+  }
+  /** Get skill catalog stats. */
+  async stats() {
+    return this._r("GET", "/api/im/skills/stats");
+  }
+  /** List available skill categories. */
+  async categories() {
+    return this._r("GET", "/api/im/skills/categories");
+  }
+  /** List trending skills. */
+  async trending(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/skills/trending", void 0, query);
+  }
+  /** List skills created by the authenticated agent. */
+  async created() {
+    return this._r("GET", "/api/im/skills/created");
+  }
+  /** Get skill detail by slug or ID. */
+  async get(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}`);
+  }
+  /** Get full SKILL.md content and package metadata. */
+  async content(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+  }
+  /** Create/submit a workspace or community skill. */
+  async create(input) {
+    return this._r("POST", "/api/im/skills", input);
+  }
+  /** Update a skill. */
+  async update(skillId, input) {
+    return this._r("PATCH", `/api/im/skills/${encodeURIComponent(skillId)}`, input);
+  }
+  /** Soft-delete/deprecate a skill. */
+  async delete(skillId) {
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(skillId)}`);
+  }
+  /** Install a skill for the authenticated agent. */
+  async install(slugOrId, scope) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
+  }
+  /** Uninstall a skill for the authenticated agent. */
+  async uninstall(slugOrId, scope) {
+    const query = scope ? { scope } : void 0;
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, void 0, query);
+  }
+  /**
+   * List installed skills. When agentId is supplied, this uses the v2.0 Layer 5
+   * route and includes daemon sync state; otherwise it keeps the legacy current-agent route.
+   */
+  async installed(options) {
+    const query = {};
+    if (options?.workspaceId) query.workspaceId = options.workspaceId;
+    if (options?.includeInactive) query.includeInactive = "true";
+    if (options?.agentId) {
+      return this._r("GET", `/api/im/agents/${encodeURIComponent(options.agentId)}/skills`, void 0, query);
+    }
+    return this._r("GET", "/api/im/skills/installed", void 0, query);
+  }
+  /** Install a skill to a specific agent. */
+  async installForAgent(agentId, skillIdOrSlug, options) {
+    return this._r("POST", `/api/im/agents/${encodeURIComponent(agentId)}/skills`, {
+      skillId: skillIdOrSlug,
+      ...options
+    });
+  }
+  /** Disable/uninstall a skill from a specific agent. Built-ins are disabled cloud-side. */
+  async uninstallFromAgent(agentId, skillIdOrSlug, options) {
+    return this._r("DELETE", `/api/im/agents/${encodeURIComponent(agentId)}/skills`, {
+      skillId: skillIdOrSlug,
+      workspaceId: options?.workspaceId
+    });
+  }
+  /** List skills whose daemon sync state is not current. */
+  async pending(agentId, workspaceId) {
+    const query = workspaceId ? { workspaceId } : void 0;
+    return this._r("GET", `/api/im/agents/${encodeURIComponent(agentId)}/skills/pending`, void 0, query);
+  }
+  /** Acknowledge daemon sync for an installed skill. */
+  async ack(agentId, input) {
+    return this._r("POST", `/api/im/agents/${encodeURIComponent(agentId)}/skills/ack`, input);
+  }
+  /** Star a skill. */
+  async star(skillId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+  }
+};
 var EvolutionClient = class {
   constructor(_r) {
     this._r = _r;
+    this.skills = new EvolutionSkillsClient(_r);
   }
   // ── Public endpoints (no auth required) ──
   /** Get evolution stats */
@@ -2446,7 +2589,7 @@ var EvolutionClient = class {
     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 };
+      return { ok: false, ...analysis.error ? { error: analysis.error } : {} };
     }
     const data = analysis.data;
     const geneId = data.gene_id;
@@ -2560,39 +2703,35 @@ var EvolutionClient = class {
   }
   /** 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);
+    return this.skills.search(options);
   }
   /** Get skill catalog stats */
   async getSkillStats() {
-    return this._r("GET", "/api/im/skills/stats");
+    return this.skills.stats();
   }
   /** Install a skill — creates Gene + returns content + install guide */
   async installSkill(slugOrId, scope) {
-    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
+    return this.skills.install(slugOrId, scope);
   }
   /** Uninstall a skill */
-  async uninstallSkill(slugOrId) {
-    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  async uninstallSkill(slugOrId, scope) {
+    return this.skills.uninstall(slugOrId, scope);
   }
   /** List installed skills for this agent */
-  async installedSkills() {
-    return this._r("GET", "/api/im/skills/installed");
+  async installedSkills(options) {
+    return this.skills.installed(options);
   }
   /** Get full skill content (SKILL.md + package info) */
   async getSkillContent(slugOrId) {
-    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+    return this.skills.content(slugOrId);
   }
   /** Create/submit a community skill */
   async createSkill(input) {
-    return this._r("POST", "/api/im/skills", input);
+    return this.skills.create(input);
   }
   /** Star a skill (increment community rating) */
   async starSkill(skillId) {
-    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+    return this.skills.star(skillId);
   }
   /**
    * Install a skill and write SKILL.md to local filesystem.
@@ -2602,53 +2741,60 @@ var EvolutionClient = class {
    */
   async installSkillLocal(slugOrId, options) {
     const result = await this.installSkill(slugOrId);
-    if (!result.ok || !result.data) return result;
-    let content = result.data.skill?.content || "";
+    if (!result.ok || !result.data) {
+      return result;
+    }
+    const installData = result.data;
+    const withLocalPaths = (localPaths2) => ({
+      ok: true,
+      data: { ...installData, localPaths: localPaths2 }
+    });
+    let content = installData.skill?.content || "";
     if (!content) {
       const contentResult = await this.getSkillContent(slugOrId);
       content = contentResult.data?.content || "";
     }
     if (!content) {
-      return { ...result, data: { ...result.data, localPaths: [] } };
+      return withLocalPaths([]);
     }
-    const rawSlug = result.data.skill?.slug || slugOrId;
+    const rawSlug = installData.skill?.slug || slugOrId;
     const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
     if (!slug) {
-      return { ...result, data: { ...result.data, localPaths: [] } };
+      return withLocalPaths([]);
     }
     const localPaths = [];
     try {
-      const fs4 = await import("fs");
-      const path4 = await import("path");
+      const fs5 = await import("fs");
+      const path5 = await import("path");
       const os3 = await import("os");
       const home = os3.homedir();
-      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path4.join(home, ".claude", "plugins", "prismer");
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path5.join(home, ".claude", "plugins", "prismer");
       const platformPaths = options?.project ? {
-        "claude-code": path4.join(options.projectRoot || ".", ".claude", "skills", slug),
-        "openclaw": path4.join(options.projectRoot || ".", "skills", slug),
-        "opencode": path4.join(options.projectRoot || ".", ".opencode", "skills", slug),
-        "plugin": path4.join(options.projectRoot || ".", ".claude", "plugins", "prismer", "skills", slug)
+        "claude-code": path5.join(options.projectRoot || ".", ".claude", "skills", slug),
+        "openclaw": path5.join(options.projectRoot || ".", "skills", slug),
+        "opencode": path5.join(options.projectRoot || ".", ".opencode", "skills", slug),
+        "plugin": path5.join(options.projectRoot || ".", ".claude", "plugins", "prismer", "skills", slug)
       } : {
-        "claude-code": path4.join(home, ".claude", "skills", slug),
-        "openclaw": path4.join(home, ".openclaw", "skills", slug),
-        "opencode": path4.join(home, ".config", "opencode", "skills", slug),
-        "plugin": path4.join(pluginBase, "skills", slug)
+        "claude-code": path5.join(home, ".claude", "skills", slug),
+        "openclaw": path5.join(home, ".openclaw", "skills", slug),
+        "opencode": path5.join(home, ".config", "opencode", "skills", slug),
+        "plugin": path5.join(pluginBase, "skills", slug)
       };
-      const targets = options?.platforms || Object.keys(platformPaths);
+      const targets = options?.platforms ?? Object.keys(platformPaths);
       for (const platform of targets) {
         const dir = platformPaths[platform];
         if (!dir) continue;
         try {
-          fs4.mkdirSync(dir, { recursive: true });
-          const filePath = path4.join(dir, "SKILL.md");
-          fs4.writeFileSync(filePath, content, "utf-8");
+          fs5.mkdirSync(dir, { recursive: true });
+          const filePath = path5.join(dir, "SKILL.md");
+          fs5.writeFileSync(filePath, content, "utf-8");
           localPaths.push(filePath);
         } catch {
         }
       }
     } catch {
     }
-    return { ...result, data: { ...result.data, localPaths } };
+    return withLocalPaths(localPaths);
   }
   /**
    * Uninstall a skill and remove local SKILL.md files.
@@ -2656,24 +2802,29 @@ var EvolutionClient = class {
   async uninstallSkillLocal(slugOrId) {
     const result = await this.uninstallSkill(slugOrId);
     const removedPaths = [];
+    const withRemoved = (ok, paths) => ({
+      ok: result.ok,
+      ...result.error ? { error: result.error } : {},
+      data: { uninstalled: ok, removedPaths: paths }
+    });
     const slug = safeSlug(slugOrId);
-    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    if (!slug) return withRemoved(result.data?.uninstalled ?? false, removedPaths);
     try {
-      const fs4 = await import("fs");
-      const path4 = await import("path");
+      const fs5 = await import("fs");
+      const path5 = await import("path");
       const os3 = await import("os");
       const home = os3.homedir();
-      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path4.join(home, ".claude", "plugins", "prismer");
+      const pluginBase = process.env.PRISMER_PLUGIN_DIR || path5.join(home, ".claude", "plugins", "prismer");
       const dirs = [
-        path4.join(home, ".claude", "skills", slug),
-        path4.join(home, ".openclaw", "skills", slug),
-        path4.join(home, ".config", "opencode", "skills", slug),
-        path4.join(pluginBase, "skills", slug)
+        path5.join(home, ".claude", "skills", slug),
+        path5.join(home, ".openclaw", "skills", slug),
+        path5.join(home, ".config", "opencode", "skills", slug),
+        path5.join(pluginBase, "skills", slug)
       ];
       for (const dir of dirs) {
         try {
-          if (fs4.existsSync(dir)) {
-            fs4.rmSync(dir, { recursive: true });
+          if (fs5.existsSync(dir)) {
+            fs5.rmSync(dir, { recursive: true });
             removedPaths.push(dir);
           }
         } catch {
@@ -2681,7 +2832,7 @@ var EvolutionClient = class {
       }
     } catch {
     }
-    return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    return withRemoved(result.data?.uninstalled ?? false, removedPaths);
   }
   /**
    * Sync all installed skills to local filesystem.
@@ -2710,25 +2861,25 @@ var EvolutionClient = class {
           failed++;
           continue;
         }
-        const fs4 = await import("fs");
-        const path4 = await import("path");
+        const fs5 = await import("fs");
+        const path5 = await import("path");
         const os3 = await import("os");
         const home = os3.homedir();
-        const pluginBase = process.env.PRISMER_PLUGIN_DIR || path4.join(home, ".claude", "plugins", "prismer");
+        const pluginBase = process.env.PRISMER_PLUGIN_DIR || path5.join(home, ".claude", "plugins", "prismer");
         const platformPaths = {
-          "claude-code": path4.join(home, ".claude", "skills", slug),
-          "openclaw": path4.join(home, ".openclaw", "skills", slug),
-          "opencode": path4.join(home, ".config", "opencode", "skills", slug),
-          "plugin": path4.join(pluginBase, "skills", slug)
+          "claude-code": path5.join(home, ".claude", "skills", slug),
+          "openclaw": path5.join(home, ".openclaw", "skills", slug),
+          "opencode": path5.join(home, ".config", "opencode", "skills", slug),
+          "plugin": path5.join(pluginBase, "skills", slug)
         };
-        const targets = options?.platforms || Object.keys(platformPaths);
+        const targets = options?.platforms ?? Object.keys(platformPaths);
         for (const platform of targets) {
           const dir = platformPaths[platform];
           if (!dir) continue;
           try {
-            fs4.mkdirSync(dir, { recursive: true });
-            const filePath = path4.join(dir, "SKILL.md");
-            fs4.writeFileSync(filePath, content, "utf-8");
+            fs5.mkdirSync(dir, { recursive: true });
+            const filePath = path5.join(dir, "SKILL.md");
+            fs5.writeFileSync(filePath, content, "utf-8");
             paths.push(filePath);
           } catch {
           }
@@ -2770,12 +2921,34 @@ var EvolutionClient = class {
     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 */
+  /**
+   * Bidirectional sync: push local outcomes and pull remote updates.
+   *
+   * Accepts either the flat shape (`pushOutcomes` / `pullSince`) used by older
+   * callers or the nested shape (`push` / `pull`) that mirrors the wire format
+   * expected by `POST /api/im/evolution/sync`. The nested shape is preferred for
+   * new code because it lets you pin a scope per-side.
+   */
   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);
+    const outcomes = options?.push?.outcomes ?? options?.pushOutcomes;
+    if (outcomes) {
+      body.push = {
+        outcomes,
+        ...options?.push?.scope ? { scope: options.push.scope } : {},
+        ...options?.push?.workspaceId ? { workspaceId: options.push.workspaceId } : {}
+      };
+    }
+    const since = options?.pull?.since ?? options?.pullSince;
+    if (since != null) {
+      body.pull = {
+        since,
+        ...options?.pull?.scope ? { scope: options.pull.scope } : {}
+      };
+    }
+    const query = {};
+    if (options?.scope) query.scope = options.scope;
+    return this._r("POST", "/api/im/evolution/sync", body, query);
   }
 };
 function safeSlug(input) {
@@ -2819,6 +2992,26 @@ var WorkspacesClient = class {
   async archive(workspaceId) {
     return this._r("DELETE", `/api/im/workspaces/${workspaceId}`);
   }
+  /**
+   * Get the workspace's orchestrator agent (Chief of Staff) — readable by any
+   * member. Returns `{ workspace, orchestrator: null }` when no active
+   * appointment exists. See release 200 §4.
+   */
+  async getOrchestrator(workspaceId) {
+    return this._r("GET", `/api/im/workspaces/${workspaceId}/orchestrator`);
+  }
+  /**
+   * Appoint an agent as the workspace's orchestrator. Owner-only. If an
+   * orchestrator is already active, this auto-revokes the previous one in the
+   * same UPDATE.
+   */
+  async appointOrchestrator(workspaceId, agentImUserId) {
+    return this._r("POST", `/api/im/workspaces/${workspaceId}/orchestrator`, { agentImUserId });
+  }
+  /** Revoke the workspace's current orchestrator. Owner-only. Idempotent. */
+  async revokeOrchestrator(workspaceId) {
+    return this._r("DELETE", `/api/im/workspaces/${workspaceId}/orchestrator`);
+  }
 };
 var WorkspaceFilesClient = class {
   constructor(_r) {
@@ -2838,8 +3031,8 @@ var WorkspaceFilesClient = class {
     return this._r("POST", `/api/im/workspaces/${workspaceId}/files`, options);
   }
   /** Soft-delete the active binding at `path`. */
-  async delete(workspaceId, path4) {
-    return this._r("DELETE", `/api/im/workspaces/${workspaceId}/files`, void 0, { path: path4 });
+  async delete(workspaceId, path5) {
+    return this._r("DELETE", `/api/im/workspaces/${workspaceId}/files`, void 0, { path: path5 });
   }
   /** Daemon delta-sync workspace files since an ISO timestamp. */
   async sync(workspaceId, since) {
@@ -2852,6 +3045,83 @@ var WorkspaceFilesClient = class {
     return this._r("GET", `/api/im/workspaces/${workspaceId}/files/${fileId}/history`);
   }
 };
+var MAX_IM_ASSET_BYTES = 1024 * 1024 * 1024;
+var DIRECT_ASSET_UPLOAD_FALLBACK_STATUSES = /* @__PURE__ */ new Set([404, 501, 503]);
+function toHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256BytesHex(bytes) {
+  if (globalThis.crypto?.subtle) {
+    const ab = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(ab).set(bytes);
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", ab);
+    return toHex(new Uint8Array(digest));
+  }
+  const { createHash } = await import("crypto");
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function bytesToBlob(bytes, mimeType) {
+  const ab = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(ab).set(bytes);
+  return new Blob([ab], { type: mimeType });
+}
+function isNamedFile(input) {
+  return typeof File !== "undefined" && input instanceof File;
+}
+function normalizeStringHeaders(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") out[key] = raw;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function isDirectAssetUploadPlan(value) {
+  if (!value || typeof value !== "object") return false;
+  const plan = value;
+  if (plan.mode === "single") {
+    return typeof plan.uploadUrl === "string" && typeof plan.bucket === "string" && typeof plan.key === "string";
+  }
+  if (plan.mode === "multipart") {
+    return typeof plan.bucket === "string" && typeof plan.key === "string" && typeof plan.uploadId === "string" && typeof plan.partSizeBytes === "number" && Array.isArray(plan.parts) && plan.parts.every((part) => {
+      const item = part;
+      return typeof item.url === "string" && Number.isInteger(item.partNumber);
+    });
+  }
+  return false;
+}
+function assetUploadError(code, message) {
+  return { ok: false, error: { code, message } };
+}
+async function normalizeAssetUploadInput(input, options) {
+  let bytes;
+  let fileName;
+  if (typeof input === "string") {
+    const fs5 = await import("fs");
+    const path5 = await import("path");
+    const buf = await fs5.promises.readFile(input);
+    bytes = new Uint8Array(buf);
+    fileName = options.fileName || path5.basename(input);
+  } else if (typeof Blob !== "undefined" && input instanceof Blob) {
+    const ab = await input.arrayBuffer();
+    bytes = new Uint8Array(ab);
+    fileName = options.fileName || (isNamedFile(input) ? input.name : "");
+    if (!fileName) throw new Error("fileName is required when uploading Blob without name");
+  } else if (input instanceof Uint8Array) {
+    bytes = input;
+    fileName = options.fileName || "";
+    if (!fileName) throw new Error("fileName is required when uploading Buffer or Uint8Array");
+  } else {
+    throw new Error("Unsupported input type");
+  }
+  const sizeBytes = bytes.byteLength;
+  if (sizeBytes > MAX_IM_ASSET_BYTES) {
+    throw new Error("Asset exceeds 1 GB cap");
+  }
+  const mimeType = options.mimeType || guessMimeType(fileName);
+  const contentHash = await sha256BytesHex(bytes);
+  return { bytes, fileName, mimeType, sizeBytes, contentHash };
+}
 var AssetsClient = class {
   constructor(_r, _baseUrl, _fetchFn, _getAuthHeaders) {
     this._r = _r;
@@ -2918,57 +3188,130 @@ var AssetsClient = class {
     };
   }
   /**
-   * Upload bytes as an asset (multipart). 100 MB hard cap; >50 MB returns
-   * 413 with `USE_PRESIGNED` — use S3 presign flow for those (not yet wrapped).
+   * Upload bytes as an asset. Uses direct-to-S3 upload when the server exposes
+   * `/assets/direct-upload/*`; falls back to legacy multipart POST for local
+   * filesystem mode and older deployments. The client always sends SHA-256 for
+   * server-side byte integrity checks. Hard cap: 1 GB.
    */
   async upload(input, options) {
-    let bytes;
-    let fileName;
-    if (typeof input === "string") {
-      const fs4 = await import("fs");
-      const path4 = await import("path");
-      const buf = await fs4.promises.readFile(input);
-      bytes = new Uint8Array(buf);
-      fileName = options.fileName || path4.basename(input);
-    } else if (typeof Blob !== "undefined" && input instanceof Blob) {
-      const ab2 = await input.arrayBuffer();
-      bytes = new Uint8Array(ab2);
-      fileName = options.fileName || (input instanceof File ? input.name : "");
-      if (!fileName) throw new Error("fileName is required when uploading Blob without name");
-    } else if (input instanceof Uint8Array) {
-      bytes = input;
-      fileName = options.fileName || "";
-      if (!fileName) throw new Error("fileName is required when uploading Buffer or Uint8Array");
-    } else {
-      throw new Error("Unsupported input type");
+    const normalized = await normalizeAssetUploadInput(input, options);
+    const direct = await this._tryDirectUpload(normalized, options);
+    if (direct) return direct;
+    return this._uploadMultipart(normalized, options);
+  }
+  async _tryDirectUpload(file, options) {
+    const init = await this._postAssetJson("/direct-upload/init", {
+      workspaceId: options.workspaceId,
+      filename: file.fileName,
+      mime: file.mimeType,
+      sizeBytes: file.sizeBytes,
+      contentHash: file.contentHash
+    });
+    if (!init.response.ok) {
+      if (DIRECT_ASSET_UPLOAD_FALLBACK_STATUSES.has(init.response.status)) return null;
+      return init.data && init.data.ok === false ? {
+        ok: false,
+        error: init.data.error ?? {
+          code: "http_error",
+          message: `Direct upload init failed (${init.response.status})`
+        }
+      } : assetUploadError("http_error", `Direct upload init failed (${init.response.status})`);
+    }
+    if (!isDirectAssetUploadPlan(init.data?.data)) return null;
+    const plan = init.data.data;
+    try {
+      const parts = await this._putDirectUploadBytes(plan, file, options.onProgress);
+      const complete = await this._postAssetJson("/direct-upload/complete", {
+        workspaceId: options.workspaceId,
+        filename: file.fileName,
+        mime: file.mimeType,
+        sizeBytes: file.sizeBytes,
+        contentHash: file.contentHash,
+        kind: options.kind,
+        metadata: options.metadata,
+        sourceTaskId: options.sourceTaskId,
+        sourceAgentImUserId: options.sourceAgentImUserId,
+        bucket: plan.bucket,
+        key: plan.key,
+        ...plan.mode === "multipart" ? { uploadId: plan.uploadId, parts: parts ?? [] } : {}
+      });
+      if (!complete.response.ok) {
+        return complete.data && complete.data.ok === false ? complete.data : assetUploadError("http_error", `Direct upload complete failed (${complete.response.status})`);
+      }
+      if (!complete.data) {
+        return assetUploadError("invalid_response", "Direct upload complete returned an empty response");
+      }
+      return complete.data;
+    } catch {
+      return null;
+    }
+  }
+  async _postAssetJson(path5, body) {
+    const response = await this._fetchFn(`${this._baseUrl}/api/im/assets${path5}`, {
+      method: "POST",
+      headers: {
+        ...this._getAuthHeaders(),
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await response.json().catch(() => null);
+    return { response, data };
+  }
+  async _putDirectUploadBytes(plan, file, onProgress) {
+    if (plan.mode === "single") {
+      const response = await this._fetchFn(plan.uploadUrl, {
+        method: plan.method ?? "PUT",
+        headers: normalizeStringHeaders(plan.headers),
+        body: bytesToBlob(file.bytes, file.mimeType)
+      });
+      if (!response.ok) throw new Error(`signed PUT failed (${response.status})`);
+      onProgress?.(file.sizeBytes, file.sizeBytes);
+      return null;
     }
-    const mimeType = options.mimeType || guessMimeType(fileName);
-    const sizeBytes = bytes.byteLength;
-    if (sizeBytes > 100 * 1024 * 1024) {
-      throw new Error("Asset exceeds 100 MB cap");
+    const completedParts = [];
+    let uploaded = 0;
+    for (const part of plan.parts) {
+      const start = (part.partNumber - 1) * plan.partSizeBytes;
+      const end = Math.min(start + plan.partSizeBytes, file.sizeBytes);
+      const chunk = file.bytes.slice(start, end);
+      const response = await this._fetchFn(part.url, { method: "PUT", body: bytesToBlob(chunk, file.mimeType) });
+      if (!response.ok) throw new Error(`signed multipart PUT failed for part ${part.partNumber} (${response.status})`);
+      const etag = response.headers.get("etag")?.replace(/^"|"$/g, "");
+      if (!etag) throw new Error(`signed multipart PUT missing ETag for part ${part.partNumber}`);
+      completedParts.push({ partNumber: part.partNumber, etag });
+      uploaded += chunk.byteLength;
+      onProgress?.(uploaded, file.sizeBytes);
     }
+    return completedParts;
+  }
+  async _uploadMultipart(file, options) {
+    const { bytes, fileName, mimeType, sizeBytes, contentHash } = file;
     const formData = new FormData();
-    const ab = new ArrayBuffer(bytes.byteLength);
-    new Uint8Array(ab).set(bytes);
-    formData.append("file", new Blob([ab], { type: mimeType }), fileName);
+    formData.append("file", bytesToBlob(bytes, mimeType), fileName);
     formData.append("workspaceId", options.workspaceId);
     if (options.kind) formData.append("kind", options.kind);
     if (options.sourceAgentImUserId) formData.append("sourceAgentImUserId", options.sourceAgentImUserId);
     if (options.sourceTaskId) formData.append("sourceTaskId", options.sourceTaskId);
     if (options.metadata) formData.append("metadata", JSON.stringify(options.metadata));
+    formData.append("contentSha256", contentHash);
     const resp = await this._fetchFn(`${this._baseUrl}/api/im/assets`, {
       method: "POST",
       body: formData,
-      headers: this._getAuthHeaders()
+      headers: {
+        ...this._getAuthHeaders(),
+        "X-Content-Sha256": contentHash
+      }
     });
-    options.onProgress?.(sizeBytes, sizeBytes);
     const data = await resp.json().catch(() => ({}));
     if (!resp.ok) {
       return {
         ok: false,
-        error: data?.error || { code: "HTTP_ERROR", message: `Upload failed (${resp.status})` }
+        error: data?.error || { code: "http_error", message: `Upload failed (${resp.status})` }
       };
     }
+    options.onProgress?.(sizeBytes, sizeBytes);
     return data;
   }
 };
@@ -3088,11 +3431,11 @@ var FilesClient = class {
     let bytes;
     let fileName;
     if (typeof input === "string") {
-      const fs4 = await import("fs");
-      const path4 = await import("path");
-      const buf = await fs4.promises.readFile(input);
+      const fs5 = await import("fs");
+      const path5 = await import("path");
+      const buf = await fs5.promises.readFile(input);
       bytes = new Uint8Array(buf);
-      fileName = opts?.fileName || path4.basename(input);
+      fileName = opts?.fileName || path5.basename(input);
     } else if (typeof Blob !== "undefined" && input instanceof Blob) {
       const ab = await input.arrayBuffer();
       bytes = new Uint8Array(ab);
@@ -3334,6 +3677,7 @@ var IMRealtimeClient = class {
 };
 var IMClient = class {
   constructor(request2, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
+    this._request = request2;
     this.account = new AccountClient(request2);
     this.direct = new DirectClient(request2);
     this.groups = new GroupsClient(request2);
@@ -3360,7 +3704,7 @@ var IMClient = class {
   }
   /** IM health check */
   async health() {
-    return this.account["_r"]("GET", "/api/im/health");
+    return this._request("GET", "/api/im/health");
   }
   /** Get workspace superset view with slot filtering */
   async getWorkspace(scope, slots, includeContent) {
@@ -3368,7 +3712,22 @@ var IMClient = class {
     if (scope) params.set("scope", scope);
     if (slots?.length) params.set("slots", slots.join(","));
     if (includeContent) params.set("includeContent", "true");
-    return this.workspace["_r"]("GET", `/api/im/workspace/view?${params}`);
+    return this._request("GET", `/api/im/workspace/view?${params}`);
+  }
+  /**
+   * Issue a typed IM API request via the shared `RequestFn` pipeline.
+   *
+   * Use this when you need to hit an IM endpoint that isn't (yet) exposed by a
+   * sub-client (e.g. `/api/im/approvals`). Same auth + offline routing + retry
+   * behaviour as the typed sub-clients.
+   *
+   * @example
+   *   const res = await client.im.request<ApprovalCreateResponse>(
+   *     'POST', '/api/im/approvals', { category, title, context, options },
+   *   );
+   */
+  async request(method, path5, body, query) {
+    return this._request(method, path5, body, query);
   }
 };
 var PrismerClient = class {
@@ -3412,20 +3771,20 @@ var PrismerClient = class {
     let imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
     if (config.identity) {
       const baseRequest = imRequest;
-      imRequest = (method, path4, body, query) => {
-        if (method === "POST" && path4.includes("/messages") && body) {
+      imRequest = (method, path5, body, query) => {
+        if (method === "POST" && path5.includes("/messages") && body) {
           const b = body;
           if (!b.signature && !b.skipSigning) {
             const ready = this._identityReady || Promise.resolve();
             return ready.then(() => {
               if (this._identity) {
-                return this._signAndSend(baseRequest, method, path4, b, query);
+                return this._signAndSend(baseRequest, method, path5, b, query);
               }
-              return baseRequest(method, path4, body, query);
+              return baseRequest(method, path5, body, query);
             });
           }
         }
-        return baseRequest(method, path4, body, query);
+        return baseRequest(method, path5, body, query);
       };
     }
     this.im = new IMClient(
@@ -3436,6 +3795,10 @@ var PrismerClient = class {
       this._offlineManager,
       config.community ?? null
     );
+    this.workspaces = this.im.workspaces;
+    this.workspaceFiles = this.im.workspaceFiles;
+    this.assets = this.im.assets;
+    this.evolution = this.im.evolution;
   }
   /** Wait for identity to be ready (useful for tests or explicit await) */
   async ensureIdentity() {
@@ -3443,9 +3806,9 @@ var PrismerClient = class {
     return this._identity;
   }
   /** Auto-sign a message body and send (v1.8.0 S1) */
-  async _signAndSend(baseRequest, method, path4, body, query) {
+  async _signAndSend(baseRequest, method, path5, body, query) {
     if (this._identityReady) await this._identityReady;
-    if (!this._identity) return baseRequest(method, path4, body, query);
+    if (!this._identity) return baseRequest(method, path5, body, query);
     const content = body.content || "";
     const contentHashBytes = new Uint8Array(
       await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content))
@@ -3455,7 +3818,7 @@ var PrismerClient = class {
     const payload = `1|${this._identity.did}|${body.type || "text"}|${timestamp}|${contentHash}`;
     const payloadBytes = new TextEncoder().encode(payload);
     const signature = await this._identity.sign(payloadBytes);
-    return baseRequest(method, path4, {
+    return baseRequest(method, path5, {
       ...body,
       secVersion: 1,
       senderDid: this._identity.did,
@@ -3484,14 +3847,47 @@ var PrismerClient = class {
       await this._offlineManager.destroy();
     }
   }
+  /**
+   * Issue an authenticated raw HTTP request against the configured base URL,
+   * returning the underlying `Response` so callers can inspect headers
+   * (`Content-Range`, `Content-Length`, etc.) and stream the body.
+   *
+   * The path may be absolute (`/api/...`) or a full URL — full URLs are used
+   * verbatim (useful for following 302 redirects), otherwise the path is
+   * appended to the client's configured `baseUrl`. Authorization + `X-IM-Agent`
+   * headers are added automatically; caller-supplied headers in `init.headers`
+   * override them on collision.
+   *
+   * Use this for binary downloads / partial fetches; for normal JSON-envelope
+   * IM requests use `client.im.request()` (typed) or the typed sub-clients.
+   */
+  async fetchAuthed(url, init) {
+    const fullUrl = /^https?:\/\//i.test(url) ? url : `${this.baseUrl}${url}`;
+    const authHeaders = this._getAuthHeaders();
+    const callerHeaders = {};
+    if (init?.headers) {
+      const h = init.headers;
+      if (h instanceof Headers) {
+        h.forEach((v, k) => {
+          callerHeaders[k] = v;
+        });
+      } else if (Array.isArray(h)) {
+        for (const [k, v] of h) callerHeaders[k] = v;
+      } else {
+        Object.assign(callerHeaders, h);
+      }
+    }
+    const headers = { ...authHeaders, ...callerHeaders };
+    return this.fetchFn(fullUrl, { ...init ?? {}, headers });
+  }
   // --------------------------------------------------------------------------
   // Internal request helper
   // --------------------------------------------------------------------------
-  async _request(method, path4, body, query, _isRetry) {
+  async _request(method, path5, body, query, _isRetry) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
-      let url = `${this.baseUrl}${path4}`;
+      let url = `${this.baseUrl}${path5}`;
       if (query && Object.keys(query).length > 0) {
         url += "?" + new URLSearchParams(query).toString();
       }
@@ -3509,29 +3905,29 @@ var PrismerClient = class {
       }
       const response = await this.fetchFn(url, init);
       const data = await response.json();
-      if (response.status === 401 && this.apiKey.startsWith("eyJ") && !_isRetry && !path4.includes("/token/refresh")) {
+      if (response.status === 401 && this.apiKey.startsWith("eyJ") && !_isRetry && !path5.includes("/token/refresh")) {
         try {
           const refreshRes = await this._request("POST", "/api/im/token/refresh", void 0, void 0, true);
           if (refreshRes?.ok && refreshRes?.data?.token) {
             this.apiKey = refreshRes.data.token;
-            return this._request(method, path4, body, query, true);
+            return this._request(method, path5, body, query, true);
           }
         } catch {
         }
       }
       if (!response.ok) {
-        const err = data.error || { code: "HTTP_ERROR", message: `Request failed with status ${response.status}` };
+        const err = data.error || { code: "http_error", message: `Request failed with status ${response.status}` };
         return { ...data, success: false, ok: false, error: err };
       }
       return data;
-    } catch (error2) {
-      if (error2 instanceof Error && error2.name === "AbortError") {
-        return { success: false, ok: false, error: { code: "TIMEOUT", message: "Request timed out" } };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return { success: false, ok: false, error: { code: "timeout", message: "Request timed out" } };
       }
       return {
         success: false,
         ok: false,
-        error: { code: "NETWORK_ERROR", message: error2 instanceof Error ? error2.message : "Unknown error" }
+        error: { code: "cloud_unreachable", message: error instanceof Error ? error.message : "Unknown error" }
       };
     } finally {
       clearTimeout(timeoutId);
@@ -3601,166 +3997,554 @@ var PrismerClient = class {
   }
 };
 
-// src/ui.ts
-var pc = __toESM(require("picocolors"));
-var clack = __toESM(require("@clack/prompts"));
+// src/cli-ui.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
-var isTTY = !!process.stdout.isTTY || !!process.env.FORCE_COLOR;
-function displayBanner() {
-  if (!isTTY) return;
-  let iconPath;
+var import_node_url = require("url");
+var import_meta = {};
+var BRAILLE_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var COMPACT_BANNER = ["\u25C7 PRISMER", "  Cloud CLI"];
+function thisDirname() {
+  if (typeof __dirname !== "undefined") return __dirname;
   try {
-    iconPath = path.resolve(__dirname, "..", "icon");
-    if (!fs.existsSync(iconPath)) {
-      iconPath = path.resolve(__dirname, "..", "..", "icon");
-    }
-    if (!fs.existsSync(iconPath)) return;
-    const raw = fs.readFileSync(iconPath, "utf-8");
-    const lines = raw.split("\n");
-    const termWidth = process.stdout.columns || 80;
-    const colorized = lines.map((line) => {
-      const trimmed = line.trimEnd();
-      if (!trimmed) return "";
-      let result = "";
-      let visibleLen = 0;
-      for (const ch of trimmed) {
-        if (visibleLen >= termWidth - 1) break;
-        if (ch === "\u2592") {
-          result += pc.cyan(ch);
-        } else if (ch === "\u2593") {
-          result += pc.white(ch);
-        } else if (ch === "\u2588") {
-          result += pc.white(ch);
-        } else {
-          result += ch;
-        }
-        visibleLen++;
-      }
-      return result;
-    });
-    while (colorized.length > 0 && colorized[colorized.length - 1].trim() === "") {
-      colorized.pop();
-    }
-    console.log(colorized.join("\n"));
-    console.log();
+    const metaUrl = typeof import_meta !== "undefined" ? import_meta.url : void 0;
+    if (metaUrl) return path.dirname((0, import_node_url.fileURLToPath)(metaUrl));
   } catch {
   }
+  return process.cwd();
 }
-var SYMBOLS = {
-  success: isTTY ? "\u2713" : "[ok]",
-  // ✓
-  error: isTTY ? "\u2717" : "[error]",
-  // ✗
-  warn: isTTY ? "\u26A0" : "[warn]",
-  // ⚠
-  info: isTTY ? "\u2139" : "[info]"
-  // ℹ
-};
-function success(msg) {
-  console.log(pc.green(`${SYMBOLS.success} ${msg}`));
-}
-function error(msg) {
-  console.error(pc.red(`${SYMBOLS.error} ${msg}`));
-}
-function warn(msg) {
-  console.warn(pc.yellow(`${SYMBOLS.warn} ${msg}`));
-}
-function info(msg) {
-  console.log(pc.blue(`${SYMBOLS.info} ${msg}`));
-}
-function dim2(msg) {
-  console.log(pc.dim(msg));
+function findIconPath(size = "big") {
+  const name = size === "big" ? "icon" : "smallicon";
+  const here = thisDirname();
+  const candidates = [
+    // npm-installed: node_modules/@prismer/sdk/dist/cli.js → ../icon (SDK ships at pkg root)
+    path.resolve(here, "..", name),
+    // alternate dist layout (sub-bundle): dist/bin/cli.js → ../../icon
+    path.resolve(here, "..", "..", name),
+    // source/typecheck: src/cli-ui.ts → ../icon
+    path.resolve(here, "..", name),
+    // dev mode: cwd happens to be sdk root
+    path.resolve(process.cwd(), name),
+    path.resolve(process.cwd(), "sdk/prismer-cloud/typescript", name),
+    // legacy assets/ layout (runtime parity, in case SDK ever adopts it)
+    path.resolve(here, "..", "assets", name),
+    path.resolve(here, "..", "..", "assets", name)
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return null;
 }
-async function withSpinner(message, fn) {
-  if (!isTTY) {
-    return fn();
+var UI = class {
+  constructor(opts) {
+    this.mode = opts?.mode ?? "pretty";
+    this.stream = opts?.stream ?? process.stdout;
+    this.errStream = opts?.errStream ?? process.stderr;
+    if (opts?.color !== void 0) {
+      this.colorEnabled = opts.color;
+    } else {
+      const isTTY = this.stream.isTTY === true;
+      const noColor = Boolean(process.env["NO_COLOR"]);
+      this.colorEnabled = isTTY && !noColor;
+    }
   }
-  const s = clack.spinner();
-  s.start(message);
-  try {
-    const result = await fn();
-    s.stop(pc.green(`${SYMBOLS.success} ${message}`));
-    return result;
-  } catch (err) {
-    s.stop(pc.red(`${SYMBOLS.error} ${message}`));
-    throw err;
+  // ---- Internal color helpers ----
+  ansi(open, close, text) {
+    if (!this.colorEnabled) return text;
+    return `\x1B[${open}m${text}\x1B[${close}m`;
   }
-}
-function table(headers, rows) {
-  if (headers.length === 0) return;
-  const widths = headers.map((h, i) => {
-    const dataMax = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
-    return Math.max(h.length, dataMax);
-  });
-  const PAD = 2;
-  const headerLine = headers.map((h, i) => h.padEnd(widths[i] + PAD)).join("");
-  if (isTTY) {
-    console.log(pc.bold(headerLine));
-    const separator = widths.map((w) => "\u2500".repeat(w)).join("  ");
-    console.log(pc.dim(separator));
-  } else {
-    console.log(headerLine);
-    const separator = widths.map((w) => "-".repeat(w)).join("  ");
-    console.log(separator);
+  green(t) {
+    return this.ansi(32, 39, t);
   }
-  for (const row of rows) {
-    const line = headers.map((_, i) => (row[i] || "").padEnd(widths[i] + PAD)).join("");
-    console.log(line);
+  red(t) {
+    return this.ansi(31, 39, t);
   }
-}
-function keyValue(pairs) {
-  const keys = Object.keys(pairs);
-  if (keys.length === 0) return;
-  const maxKeyLen = keys.reduce((max, k) => Math.max(max, k.length), 0);
-  for (const key of keys) {
-    const label = isTTY ? pc.bold(key.padEnd(maxKeyLen)) : key.padEnd(maxKeyLen);
-    const value = pairs[key];
-    console.log(`  ${label}  ${value}`);
+  yellow(t) {
+    return this.ansi(33, 39, t);
   }
-}
-
-// 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);
+  cyan(t) {
+    return this.ansi(36, 39, t);
+  }
+  dim(t) {
+    return this.ansi(2, 22, t);
+  }
+  bold(t) {
+    return this.ansi(1, 22, t);
+  }
+  gray(t) {
+    return this.ansi(90, 39, t);
+  }
+  brandMark() {
+    return this.cyan("\u25C7");
+  }
+  colorBrandLine(line) {
+    let out = "";
+    for (const ch of line) {
+      if (ch === "\u2592") {
+        out += this.cyan(ch);
+      } else if (ch === "\u2593") {
+        out += this.dim(ch);
+      } else {
+        out += ch;
       }
-      if (opts.json) {
-        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
-        return;
+    }
+    return out;
+  }
+  // ---- Core write helpers ----
+  write(text) {
+    this.stream.write(text);
+  }
+  writeErr(text) {
+    this.errStream.write(text);
+  }
+  // ---- Level 1: Header ----
+  header(text) {
+    if (this.mode === "json") return;
+    const prefix = text.startsWith("Prismer") ? this.brandMark() + " " : "";
+    this.write(prefix + this.bold(text) + "\n");
+  }
+  smallHeader(subtitle) {
+    if (this.mode === "json" || this.mode === "quiet") return;
+    const iconPath = findIconPath("small");
+    if (iconPath !== null) {
+      try {
+        const raw = fs.readFileSync(iconPath, "utf-8").replace(/\n+$/, "");
+        for (const line of raw.split("\n")) {
+          this.write(this.cyan(line) + "\n");
+        }
+      } catch {
+        this.write(this.brandMark() + " " + this.bold("Prismer") + "\n");
       }
-      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);
+    } else {
+      this.write(this.brandMark() + " " + this.bold("Prismer") + "\n");
     }
-  });
-  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);
+    if (subtitle !== void 0 && subtitle.length > 0) {
+      this.write(this.dim("  " + subtitle) + "\n");
+    }
+    this.blank();
+  }
+  banner(subtitle, opts) {
+    if (this.mode === "json" || this.mode === "quiet") return;
+    const envColumns = process.env["COLUMNS"] !== void 0 ? parseInt(process.env["COLUMNS"], 10) : NaN;
+    const width = this.stream.columns ?? process.stdout.columns ?? (Number.isFinite(envColumns) ? envColumns : 80);
+    const iconPath = findIconPath("big");
+    const shouldUseFull = opts?.full === true || width >= 120;
+    if (shouldUseFull && iconPath !== null) {
+      try {
+        const raw = fs.readFileSync(iconPath, "utf-8");
+        const lines = raw.split("\n");
+        for (const line of lines) {
+          const stripped = line.trimEnd();
+          if (stripped.length === 0) {
+            this.write("\n");
+            continue;
+          }
+          const clipped = stripped.length >= width ? stripped.slice(0, Math.max(width - 1, 1)) : stripped;
+          this.write(this.colorBrandLine(clipped) + "\n");
+        }
+      } catch {
+        this.write(this.cyan(COMPACT_BANNER[0] ?? "\u25C7 PRISMER") + "\n");
+        this.write(this.dim(COMPACT_BANNER[1] ?? "  Cloud CLI") + "\n");
       }
-      const msgs = res.data || [];
-      if (opts.json) {
-        process.stdout.write(JSON.stringify(msgs, null, 2) + "\n");
-        return;
+    } else {
+      this.write(this.cyan(COMPACT_BANNER[0] ?? "\u25C7 PRISMER") + "\n");
+      this.write(this.dim(COMPACT_BANNER[1] ?? "  Cloud CLI") + "\n");
+    }
+    if (subtitle !== void 0 && subtitle.length > 0) {
+      this.write(this.dim("  " + subtitle) + "\n");
+    }
+    this.blank();
+  }
+  // ---- Level 2: Primary data ----
+  blank() {
+    if (this.mode === "json") return;
+    this.write("\n");
+  }
+  line(text) {
+    if (this.mode === "json") return;
+    this.write(text + "\n");
+  }
+  info(text) {
+    this.line(text);
+  }
+  // ---- Level 3: Secondary ----
+  secondary(text, indent = 2) {
+    if (this.mode === "json") return;
+    this.write(" ".repeat(indent) + this.dim(text) + "\n");
+  }
+  // ---- Level 4: Action tips ----
+  tip(text) {
+    if (this.mode === "json") return;
+    this.write(this.cyan("Tip:") + " " + text + "\n");
+  }
+  next(text) {
+    if (this.mode === "json") return;
+    this.write(this.cyan("Next:") + " " + text + "\n");
+  }
+  // ---- Level 5: Status indicators ----
+  ok(text, detail) {
+    if (this.mode === "json") return;
+    const suffix = detail ? "  " + this.dim(detail) : "";
+    this.write("  " + this.green("\u2713") + " " + text + suffix + "\n");
+  }
+  success(text, detail) {
+    this.ok(text, detail);
+  }
+  fail(text, detail) {
+    if (this.mode === "json") return;
+    const suffix = detail ? "  " + this.dim(detail) : "";
+    this.write("  " + this.red("\u2717") + " " + text + suffix + "\n");
+  }
+  online(text) {
+    if (this.mode === "json") return;
+    this.write("  " + this.green("\u25CF") + " " + text + "\n");
+  }
+  offline(text) {
+    if (this.mode === "json") return;
+    this.write("  " + this.gray("\u25CB") + " " + text + "\n");
+  }
+  notInstalled(text) {
+    if (this.mode === "json") return;
+    this.write("  " + this.dim("\xB7") + " " + this.dim(text) + "\n");
+  }
+  pending(text) {
+    if (this.mode === "json") return;
+    this.write("  " + this.yellow("\u27F3") + " " + text + "\n");
+  }
+  warn(text, detail) {
+    if (this.mode === "json") return;
+    const suffix = detail ? "  " + this.dim(detail) : "";
+    this.write("  " + this.yellow("!") + " " + text + suffix + "\n");
+  }
+  // ---- Level 6: Error block ----
+  error(what, cause, fix) {
+    if (this.mode === "json") return;
+    this.writeErr(this.red("\u2717") + " " + what + "\n");
+    if (cause !== void 0) {
+      this.writeErr("  " + this.dim("Cause:") + " " + this.dim(cause) + "\n");
+    }
+    if (fix !== void 0) {
+      this.writeErr("  " + this.cyan("Fix:") + " " + fix + "\n");
+    }
+  }
+  table(rowsOrOpts, maybeOpts) {
+    if (this.mode === "json") return;
+    const rows = Array.isArray(rowsOrOpts) ? rowsOrOpts : rowsOrOpts.rows;
+    const opts = Array.isArray(rowsOrOpts) ? maybeOpts : { columns: rowsOrOpts.columns, maxWidth: rowsOrOpts.maxWidth };
+    if (!opts) throw new Error("table() requires columns");
+    const maxWidth = opts.maxWidth ?? (process.stdout.columns || 80);
+    const cols = opts.columns;
+    const widths = cols.map((col) => col.length);
+    for (const row of rows) {
+      cols.forEach((col, i) => {
+        const val = row[col] ?? "";
+        const w = widths[i] ?? 0;
+        if (val.length > w) widths[i] = val.length;
+      });
+    }
+    const totalWidth = widths.reduce((a, b) => a + b, 0) + (cols.length - 1) * 2 + 2;
+    if (totalWidth > maxWidth) {
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        if (!row) continue;
+        for (const col of cols) {
+          const val = row[col] ?? "";
+          this.write("  " + this.bold(col + ":") + " " + val + "\n");
+        }
+        if (i < rows.length - 1) this.write("\n");
+      }
+      return;
+    }
+    const header = cols.map((col, i) => col.toUpperCase().padEnd(widths[i] ?? col.length)).join("  ");
+    this.write("  " + this.dim(header) + "\n");
+    for (const row of rows) {
+      const line = cols.map((col, i) => (row[col] ?? "").padEnd(widths[i] ?? col.length)).join("  ");
+      this.write("  " + line + "\n");
+    }
+  }
+  // ---- Spinner ----
+  spinner(text) {
+    if (this.mode === "quiet" || this.mode === "json") {
+      return {
+        update() {
+        },
+        stop() {
+        }
+      };
+    }
+    const isTTY = this.stream.isTTY === true;
+    if (!isTTY || !this.colorEnabled) {
+      this.write("  " + this.yellow("\u27F3") + " " + text + "\n");
+      return {
+        update: (t) => {
+          this.write("  " + this.yellow("\u27F3") + " " + t + "\n");
+        },
+        stop: (final) => {
+          if (final) this.write("  " + this.green("\u2713") + " " + final + "\n");
+        }
+      };
+    }
+    let current = text;
+    let frameIdx = 0;
+    let stopped = false;
+    const write = this.write.bind(this);
+    const colorFn = this.yellow.bind(this);
+    const greenFn = this.green.bind(this);
+    function renderFrame() {
+      const frame = BRAILLE_FRAMES[frameIdx % BRAILLE_FRAMES.length] ?? "\u280B";
+      const line = "  " + colorFn(frame) + " " + current;
+      write("\r" + line);
+      frameIdx++;
+    }
+    renderFrame();
+    const timer = setInterval(renderFrame, 80);
+    return {
+      update(t) {
+        if (stopped) return;
+        current = t;
+      },
+      stop(final) {
+        if (stopped) return;
+        stopped = true;
+        clearInterval(timer);
+        write("\r\x1B[2K");
+        if (final) write("  " + greenFn("\u2713") + " " + final + "\n");
+      }
+    };
+  }
+  // ---- Progress bar ----
+  progress(text, total) {
+    if (this.mode === "quiet" || this.mode === "json") {
+      return {
+        update() {
+        },
+        stop() {
+        }
+      };
+    }
+    const isTTY = this.stream.isTTY === true;
+    const start = Date.now();
+    const write = this.write.bind(this);
+    const colorFn = this.cyan.bind(this);
+    const dimFn = this.dim.bind(this);
+    const greenFn = this.green.bind(this);
+    let last = 0;
+    let lastDetail = "";
+    let stopped = false;
+    const render = () => {
+      if (stopped) return;
+      const frac = total > 0 ? Math.min(1, Math.max(0, last / total)) : 0;
+      const pct = Math.floor(frac * 100);
+      const width = 20;
+      const filled = Math.floor(frac * width);
+      const bar = "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+      const elapsed = (Date.now() - start) / 1e3;
+      const eta = frac > 0.01 ? Math.max(0, elapsed / frac - elapsed) : 0;
+      const etaStr = frac >= 1 ? "" : ` \xB7 ${eta < 1 ? "<1s" : Math.round(eta) + "s"} left`;
+      const detailStr = lastDetail ? ` \xB7 ${lastDetail}` : "";
+      const line = `  ${text} [${colorFn(bar)}] ${String(pct).padStart(3)}%${detailStr}${dimFn(etaStr)}`;
+      if (isTTY && this.colorEnabled) {
+        write("\r\x1B[2K" + line);
+      } else {
+        write(line + "\n");
+      }
+    };
+    render();
+    return {
+      update: (current, detail) => {
+        if (stopped) return;
+        last = current;
+        if (detail !== void 0) lastDetail = detail;
+        render();
+      },
+      stop: (final) => {
+        if (stopped) return;
+        stopped = true;
+        if (isTTY && this.colorEnabled) write("\r\x1B[2K");
+        if (final) write("  " + greenFn("\u2713") + " " + final + "\n");
+      }
+    };
+  }
+  // ---- JSON output ----
+  json(payload, opts) {
+    const indent = opts?.pretty ? 2 : void 0;
+    this.write(JSON.stringify(payload, null, indent) + "\n");
+  }
+  result(pretty, jsonPayload) {
+    if (this.mode === "pretty") {
+      pretty();
+    } else {
+      this.json(jsonPayload);
+    }
+  }
+};
+var _ui = null;
+function getUI() {
+  if (!_ui) _ui = new UI();
+  return _ui;
+}
+function setUI(ui) {
+  _ui = ui;
+}
+function applyCommonFlags(argv) {
+  let mode = "pretty";
+  const isTTY = process.stdout.isTTY === true;
+  const noColorEnv = Boolean(process.env["NO_COLOR"]);
+  let color = isTTY && !noColorEnv;
+  const rest = [];
+  for (const arg of argv) {
+    switch (arg) {
+      case "--no-color":
+        color = false;
+        break;
+      case "--color":
+        color = true;
+        break;
+      case "--json":
+      case "--pretty-json":
+        mode = "json";
+        if (arg === "--json") rest.push(arg);
+        break;
+      case "--quiet":
+        mode = "quiet";
+        break;
+      default:
+        rest.push(arg);
+    }
+  }
+  return { mode, color, restArgv: rest };
+}
+function displayBanner(subtitle) {
+  getUI().banner(subtitle ?? "Cloud CLI v2.0.0", { full: true });
+}
+function success(msg) {
+  getUI().ok(msg);
+}
+function warn(msg) {
+  getUI().warn(msg);
+}
+function info(msg) {
+  getUI().info(msg);
+}
+function dim(msg) {
+  getUI().secondary(msg);
+}
+function errorLine(msg) {
+  const ui = getUI();
+  if (ui.mode === "json") {
+    ui.json({ ok: false, error: { code: "cli_error", message: msg } }, { pretty: true });
+    return;
+  }
+  ui.writeErr("Error: " + msg + "\n");
+}
+function keyValue(pairs) {
+  const ui = getUI();
+  if (ui.mode === "json") {
+    ui.json(pairs);
+    return;
+  }
+  const keys = Object.keys(pairs);
+  if (keys.length === 0) return;
+  const maxKeyLen = keys.reduce((max, k) => Math.max(max, k.length), 0);
+  for (const key of keys) {
+    const label = key.padEnd(maxKeyLen);
+    const value = pairs[key] ?? "";
+    ui.line("  " + label + "  " + value);
+  }
+}
+function table(headers, rows) {
+  const objectRows = rows.map((r) => {
+    const obj = {};
+    headers.forEach((h, i) => {
+      obj[h] = r[i] ?? "";
+    });
+    return obj;
+  });
+  getUI().table(objectRows, { columns: headers });
+}
+async function withSpinner(message, fn) {
+  const sp = getUI().spinner(message);
+  try {
+    const result = await fn();
+    sp.stop(message);
+    return result;
+  } catch (err) {
+    sp.stop();
+    throw err;
+  }
+}
+
+// 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-or-username> <message>").description("Send a direct message to a user (id by default, --by-username to resolve)").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("--conversation-id <id>", "Pin message to a specific conversation/session").option("--asset-id <id>", "Attach a previously uploaded asset (treats type as file)").option("--by-username", "Treat the first arg as a username; resolve to imUserId first").option("--json", "Output raw JSON response").action(async (target, message, opts) => {
+    const client = getIMClient2();
+    try {
+      let userId = target;
+      if (opts.byUsername) {
+        const discoverRes = await client.im.contacts.discover();
+        if (!discoverRes.ok || !Array.isArray(discoverRes.data)) {
+          process.stderr.write(`Error: could not resolve username "${target}" \u2014 discover failed.
+`);
+          process.exit(1);
+        }
+        const needle = target.trim().toLowerCase().replace(/^@/, "");
+        const match = discoverRes.data.find((u) => {
+          const vals = [u.username, u.displayName, u.userId].map(
+            (v) => typeof v === "string" ? v.trim().toLowerCase() : ""
+          );
+          return vals.includes(needle);
+        });
+        if (!match?.userId || typeof match.userId !== "string") {
+          process.stderr.write(`Error: could not resolve username "${target}" to an IM user.
+`);
+          process.exit(1);
+        }
+        userId = match.userId;
+      }
+      let effectiveType = opts.type;
+      if (opts.assetId && (!effectiveType || effectiveType === "text")) effectiveType = "file";
+      const sendOpts = {
+        type: effectiveType
+      };
+      if (opts.replyTo) sendOpts.parentId = opts.replyTo;
+      if (opts.assetId) {
+        sendOpts.attachments = [{ kind: "asset", assetId: opts.assetId, role: "attachment" }];
+      }
+      const res = opts.conversationId ? await client.im.messages.send(opts.conversationId, message, sendOpts) : 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");
@@ -3819,12 +4603,16 @@ function register(parent, getIMClient2, _getAPIClient) {
       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) => {
+  im.command("discover").description("Discover available agents").option("--type <type>", "Filter by agent type").option("--capability <cap>", "Filter by capability").option("--online-only", "Only return agents currently online").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;
+      if (opts.onlineOnly) {
+        discoverOpts.status = "online";
+        discoverOpts.onlineOnly = "true";
+      }
       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)}
@@ -3888,9 +4676,50 @@ function register(parent, getIMClient2, _getAPIClient) {
       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) => {
+  im.command("conversations [conversation-id]").description("List conversations, or show details for one (use --members to list participants)").option("--unread", "Show only conversations with unread messages (list mode only)").option("--members", "When a conversation id is provided, list its agent + human participants").option("--json", "Output raw JSON response").action(async (conversationId, opts) => {
     const client = getIMClient2();
     try {
+      if (conversationId) {
+        const res2 = await client.im.conversations.get(conversationId);
+        if (!res2.ok) {
+          process.stderr.write(`Error: ${res2.error?.message || JSON.stringify(res2.error)}
+`);
+          process.exit(1);
+        }
+        const conv = res2.data;
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(opts.members ? conv?.participants ?? [] : conv, null, 2) + "\n");
+          return;
+        }
+        if (opts.members) {
+          const participants = conv?.participants ?? [];
+          if (participants.length === 0) {
+            process.stdout.write("No participants.\n");
+            return;
+          }
+          process.stdout.write(
+            "User ID".padEnd(36) + "Role".padEnd(12) + "Type".padEnd(10) + "Display Name\n"
+          );
+          for (const p of participants) {
+            const user = p.user ?? {};
+            process.stdout.write(
+              `${String(user.id ?? "").padEnd(36)}${String(p.role ?? "").padEnd(12)}${String(user.role ?? "").padEnd(10)}${String(user.displayName ?? user.username ?? "")}
+`
+            );
+          }
+          return;
+        }
+        process.stdout.write(`ID:           ${conv?.id ?? ""}
+`);
+        process.stdout.write(`Type:         ${conv?.type ?? ""}
+`);
+        process.stdout.write(`Title:        ${conv?.title ?? ""}
+`);
+        const participantCount = Array.isArray(conv?.participants) ? (conv?.participants).length : 0;
+        process.stdout.write(`Participants: ${participantCount}
+`);
+        return;
+      }
       const listOpts = {};
       if (opts.unread) {
         listOpts.withUnread = true;
@@ -4200,9 +5029,9 @@ function register2(parent, _getIMClient, getAPIClient2) {
       }
       for (const item of results) {
         process.stdout.write(`
---- ${item.url ?? item.input ?? "result"} ---
+--- ${item.url ?? "result"} ---
 `);
-        const hqcc = item.hqcc ?? item.content ?? "";
+        const hqcc = item.hqcc ?? item.raw ?? "";
         if (hqcc) {
           const truncated = hqcc.length > 2e3 ? hqcc.slice(0, 2e3) + "... [truncated]" : hqcc;
           process.stdout.write(truncated + "\n");
@@ -4242,9 +5071,9 @@ function register2(parent, _getIMClient, getAPIClient2) {
 
 `);
       results.forEach((item, i) => {
-        process.stdout.write(`[${i + 1}] ${item.url ?? item.input ?? "result"}
+        process.stdout.write(`[${i + 1}] ${item.url ?? "result"}
 `);
-        const hqcc = item.hqcc ?? item.content ?? "";
+        const hqcc = item.hqcc ?? item.raw ?? "";
         if (hqcc) {
           const truncated = hqcc.length > 2e3 ? hqcc.slice(0, 2e3) + "... [truncated]" : hqcc;
           process.stdout.write(truncated + "\n");
@@ -4283,6 +5112,8 @@ function register2(parent, _getIMClient, getAPIClient2) {
 }
 
 // src/commands/evolve.ts
+var GENE_CATEGORIES = /* @__PURE__ */ new Set(["repair", "optimize", "innovate", "diagnostic"]);
+var GENE_SORTS = /* @__PURE__ */ new Set(["newest", "most_used", "highest_success"]);
 function parseSignals(raw) {
   if (!raw) return void 0;
   const trimmed = raw.trim();
@@ -4295,6 +5126,21 @@ function parseSignals(raw) {
   }
   return trimmed.split(",").map((s) => s.trim()).filter(Boolean);
 }
+function parseOutcome(raw) {
+  if (raw === "success" || raw === "failed") return raw;
+  if (raw === "failure") return "failed";
+  throw new Error(`Invalid outcome "${raw}". Expected success or failed.`);
+}
+function parseGeneCategory(raw) {
+  if (!raw) return void 0;
+  if (GENE_CATEGORIES.has(raw)) return raw;
+  throw new Error(`Invalid gene category "${raw}". Expected repair, optimize, innovate, or diagnostic.`);
+}
+function parseGeneSort(raw) {
+  if (!raw) return void 0;
+  if (GENE_SORTS.has(raw)) return raw;
+  throw new Error(`Invalid sort "${raw}". Expected newest, most_used, or highest_success.`);
+}
 function handleError(err) {
   const message = err instanceof Error ? err.message : String(err);
   process.stderr.write(`Error: ${message}
@@ -4358,14 +5204,15 @@ function register3(parent, getIMClient2, _getAPIClient) {
   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 signals = parseSignals(opts.signals) ?? [];
       const score = opts.score !== void 0 ? parseFloat(opts.score) : void 0;
+      const outcome = parseOutcome(opts.outcome);
       const res = await client.im.evolution.record({
         gene_id: opts.gene,
         signals,
-        outcome: opts.outcome,
+        outcome,
         score,
-        summary: opts.summary,
+        summary: opts.summary ?? "",
         scope: opts.scope
       });
       if (opts.json) {
@@ -4382,7 +5229,7 @@ function register3(parent, getIMClient2, _getAPIClient) {
     try {
       const res = await client.im.evolution.submitReport({
         rawContext: opts.error,
-        outcome: opts.status,
+        outcome: parseOutcome(opts.status),
         taskContext: opts.task
       });
       if (opts.json && !opts.wait) {
@@ -4416,7 +5263,7 @@ function register3(parent, getIMClient2, _getAPIClient) {
       const maxIterations = 30;
       let lastStatus;
       for (let i = 0; i < maxIterations; i++) {
-        await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+        await new Promise((resolve3) => setTimeout(resolve3, 2e3));
         if (!opts.json) process.stdout.write(".");
         const statusRes = await client.im.evolution.getReportStatus(traceId);
         if (!statusRes.ok) break;
@@ -4476,7 +5323,7 @@ function register3(parent, getIMClient2, _getAPIClient) {
     try {
       const signals_match = parseSignals(opts.signals) ?? [];
       const res = await client.im.evolution.createGene({
-        category: opts.category,
+        category: parseGeneCategory(opts.category),
         signals_match,
         strategy: opts.strategy,
         title: opts.name,
@@ -4682,9 +5529,9 @@ function register3(parent, getIMClient2, _getAPIClient) {
     try {
       const limit = parseInt(opts.limit ?? "20", 10);
       const res = await client.im.evolution.browseGenes({
-        category: opts.category,
+        category: parseGeneCategory(opts.category),
         search: opts.search,
-        sort: opts.sort,
+        sort: parseGeneSort(opts.sort),
         limit
       });
       if (opts.json) {
@@ -4799,17 +5646,89 @@ function register3(parent, getIMClient2, _getAPIClient) {
 }
 
 // src/commands/task.ts
+var TASK_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned", "running", "review", "completed", "failed", "cancelled"]);
+var TASK_PRIORITIES = /* @__PURE__ */ new Set(["low", "medium", "high", "urgent"]);
+var TASK_KINDS = /* @__PURE__ */ new Set(["work_item", "goal"]);
+function parseTaskStatus(raw) {
+  if (!raw) return void 0;
+  if (TASK_STATUSES.has(raw)) return raw;
+  throw new Error(`Invalid task status "${raw}".`);
+}
+async function resolveAssigneeId(client, name) {
+  const needle = name.trim().toLowerCase();
+  const normalized = needle.replace(/^@/, "");
+  if (!needle) return "";
+  const res = await client.im.contacts.discover();
+  if (!res.ok || !Array.isArray(res.data)) return "";
+  const agents = res.data;
+  const exact = agents.find((agent) => {
+    const values = [agent.userId, agent.username, agent.displayName].map(
+      (v) => typeof v === "string" ? v.trim().toLowerCase() : ""
+    );
+    return values.includes(needle) || values.includes(normalized);
+  });
+  if (exact && typeof exact.userId === "string") return exact.userId;
+  const fuzzy = agents.find((agent) => {
+    const labels = [agent.username, agent.displayName].map((v) => typeof v === "string" ? v.trim().toLowerCase() : "").filter(Boolean);
+    return labels.some((label) => label.includes(normalized) || normalized.includes(label));
+  });
+  return fuzzy && typeof fuzzy.userId === "string" ? fuzzy.userId : "";
+}
 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("--capability <capability>", "required agent capability").option("--budget <budget>", "budget in credits", parseFloat).option("--json", "output raw JSON response").action(async (opts) => {
+  task.command("create").description("Create a new task").requiredOption("--title <title>", "task title").option("--description <description>", "task description").option("--capability <capability>", "required agent capability").option("--budget <budget>", "budget in credits", parseFloat).option("--reward <reward>", "alias for --budget (credits offered for completion)", parseFloat).option("--priority <priority>", "task priority: low | medium | high | urgent").option("--assignee-id <imUserId>", "directly assign to a specific agent by IM user id").option("--assignee-name <name>", "assign by @username / display name (resolved via discover)").option("--conversation-id <id>", "pin task to a conversation/session").option("--kind <kind>", "board projection kind: work_item (default) | goal", "work_item").option("--schedule-at <iso>", "one-shot ISO 8601 scheduled time (sets scheduleType=once)").option("--schedule-cron <expr>", "cron expression (sets scheduleType=cron)").option("--json", "output raw JSON response").action(async (opts) => {
     const client = getIMClient2();
     try {
-      const res = await client.im.tasks.create({
+      if (opts.priority && !TASK_PRIORITIES.has(opts.priority)) {
+        throw new Error(`Invalid --priority "${opts.priority}". Use one of: low, medium, high, urgent.`);
+      }
+      const kind = opts.kind ?? "work_item";
+      if (!TASK_KINDS.has(kind)) {
+        throw new Error(`Invalid --kind "${kind}". Use one of: work_item, goal.`);
+      }
+      let assigneeId = opts.assigneeId;
+      if (!assigneeId && opts.assigneeName) {
+        assigneeId = await resolveAssigneeId(client, opts.assigneeName);
+        if (!assigneeId) {
+          throw new Error(
+            `--assignee-name "${opts.assigneeName}" did not resolve to an agent. Use a visible agent username/display name or pass --assignee-id explicitly.`
+          );
+        }
+      }
+      const budget = opts.budget ?? opts.reward;
+      const metadata = { kind };
+      if (opts.priority) metadata.priority = opts.priority;
+      if (opts.conversationId) {
+        metadata.context = { linkedConversationId: opts.conversationId };
+      }
+      if (kind === "goal") {
+        metadata.intent = "standing_objective";
+        metadata.goal = {
+          status: "active",
+          priority: opts.priority === "urgent" ? "high" : opts.priority ?? "medium",
+          linkedConversationIds: opts.conversationId ? [opts.conversationId] : [],
+          linkedTaskIds: [],
+          lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const createOpts = {
         title: opts.title,
         description: opts.description,
         capability: opts.capability,
-        budget: opts.budget
-      });
+        budget,
+        metadata
+      };
+      if (assigneeId) createOpts.assigneeId = assigneeId;
+      if (opts.conversationId) createOpts.conversationId = opts.conversationId;
+      if (opts.scheduleAt) {
+        createOpts.scheduleType = "once";
+        createOpts.scheduleAt = opts.scheduleAt;
+      }
+      if (opts.scheduleCron) {
+        createOpts.scheduleType = "cron";
+        createOpts.scheduleCron = opts.scheduleCron;
+      }
+      const res = await client.im.tasks.create(createOpts);
       if (opts.json) {
         process.stdout.write(JSON.stringify(res, null, 2) + "\n");
         return;
@@ -4846,7 +5765,7 @@ function register4(parent, getIMClient2, _getAPIClient) {
     const client = getIMClient2();
     try {
       const res = await client.im.tasks.list({
-        status: opts.status,
+        status: parseTaskStatus(opts.status),
         capability: opts.capability,
         limit: parseInt(opts.limit, 10)
       });
@@ -4900,7 +5819,8 @@ ${tasks.length} task(s) listed.
 `);
         process.exit(1);
       }
-      const t = res.data;
+      const detail = res.data;
+      const t = detail.task;
       process.stdout.write(`ID:           ${t.id}
 `);
       process.stdout.write(`Title:        ${t.title}
@@ -4931,14 +5851,14 @@ ${tasks.length} task(s) listed.
 `);
       if (t.error) process.stdout.write(`Error:        ${t.error}
 `);
-      const logs = t.logs ?? t.taskLogs ?? [];
+      const logs = detail.logs ?? [];
       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);
+          const ts = log.createdAt ?? "";
+          const msg = log.message ?? JSON.stringify(log);
           process.stdout.write(`  [${ts}] ${msg}
 `);
         }
@@ -5179,16 +6099,23 @@ Logs (${logs.length}):
 }
 
 // src/commands/memory.ts
+var MEMORY_TYPES = /* @__PURE__ */ new Set(["user", "feedback", "project", "reference"]);
 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) => {
+  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("--type <type>", "memory type: user | feedback | project | reference").option("--description <description>", "human-readable description of this memory").option("--json", "output raw JSON response").action(async (opts) => {
     const client = getIMClient2();
     try {
-      const res = await client.im.memory.createFile({
+      if (opts.type && !MEMORY_TYPES.has(opts.type)) {
+        throw new Error(`Invalid --type "${opts.type}". Use one of: user, feedback, project, reference.`);
+      }
+      const body = {
         scope: opts.scope,
         path: opts.path,
         content: opts.content
-      });
+      };
+      if (opts.type) body.memoryType = opts.type;
+      if (opts.description) body.description = opts.description;
+      const res = await client.im.memory.createFile(body);
       if (opts.json) {
         process.stdout.write(JSON.stringify(res, null, 2) + "\n");
         return;
@@ -5199,6 +6126,7 @@ function register5(parent, getIMClient2, _getAPIClient) {
         process.exit(1);
       }
       const file = res.data;
+      if (!file) throw new Error("Memory file response missing data");
       process.stdout.write(`Memory file created
 `);
       process.stdout.write(`  ID:    ${file.id}
@@ -5229,6 +6157,7 @@ function register5(parent, getIMClient2, _getAPIClient) {
           process.exit(1);
         }
         const file = res.data;
+        if (!file) throw new Error("Memory file response missing data");
         process.stdout.write(`ID:    ${file.id}
 `);
         process.stdout.write(`Scope: ${file.scope}
@@ -5246,7 +6175,9 @@ ${file.content ?? ""}
       });
       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);
+          const first = listRes.data[0];
+          if (!first) throw new Error("Memory file response missing data");
+          const detailRes = await client.im.memory.getFile(first.id);
           process.stdout.write(JSON.stringify(detailRes, null, 2) + "\n");
         } else {
           process.stdout.write(JSON.stringify(listRes, null, 2) + "\n");
@@ -5264,13 +6195,16 @@ ${file.content ?? ""}
         return;
       }
       if (files.length === 1) {
-        const detailRes = await client.im.memory.getFile(files[0].id);
+        const first = files[0];
+        if (!first) throw new Error("Memory file response missing data");
+        const detailRes = await client.im.memory.getFile(first.id);
         if (!detailRes.ok) {
           process.stderr.write(`Error: ${detailRes.error?.message || "Unknown error"}
 `);
           process.exit(1);
         }
         const file = detailRes.data;
+        if (!file) throw new Error("Memory file response missing data");
         process.stdout.write(`ID:    ${file.id}
 `);
         process.stdout.write(`Scope: ${file.scope}
@@ -5338,10 +6272,10 @@ ${file.content ?? ""}
       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) => {
+  mem.command("compact <conversation-id>").description("Create a compaction summary for a conversation").requiredOption("--summary <text>", "summary text to persist").option("--json", "output raw JSON response").action(async (conversationId, opts) => {
     const client = getIMClient2();
     try {
-      const res = await client.im.memory.compact({ conversationId });
+      const res = await client.im.memory.compact({ conversationId, summary: opts.summary });
       if (opts.json) {
         process.stdout.write(JSON.stringify(res, null, 2) + "\n");
         return;
@@ -5365,6 +6299,66 @@ ${file.content ?? ""}
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("extract").description("Extract structured memory entries from a session journal (v1.8.0 P1)").requiredOption("--journal <text>", "session journal text (min 50 chars)").option("--scope <scope>", "evolution scope", "global").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory._r("POST", "/api/im/memory/extract", { journal: opts.journal, 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);
+      }
+      process.stdout.write("Memory extraction complete\n");
+      const data = res.data;
+      if (data) {
+        if (Array.isArray(data.extracted)) {
+          process.stdout.write(`  Extracted: ${data.extracted.length}
+`);
+        }
+        if (Array.isArray(data.created)) {
+          process.stdout.write(`  Created:   ${data.created.length}
+`);
+        }
+        if (Array.isArray(data.updated)) {
+          process.stdout.write(`  Updated:   ${data.updated.length}
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("consolidate").description("Trigger Dream consolidation (cluster + reflect across memories)").option("--scope <scope>", "evolution scope", "global").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory._r("POST", "/api/im/memory/consolidate", { 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);
+      }
+      process.stdout.write("Dream consolidation triggered\n");
+      if (res.data && typeof res.data === "object") {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
 `);
       process.exit(1);
     }
@@ -5405,7 +6399,7 @@ function printFileTable(files) {
   const idLen = Math.max(2, ...files.map((f) => f.id.length));
   const scopeLen = Math.max(5, ...files.map((f) => f.scope.length));
   const pathLen = Math.max(4, ...files.map((f) => f.path.length));
-  const row = (id, scope, path4) => `${id.padEnd(idLen)}  ${scope.padEnd(scopeLen)}  ${path4.padEnd(pathLen)}`;
+  const row = (id, scope, path5) => `${id.padEnd(idLen)}  ${scope.padEnd(scopeLen)}  ${path5.padEnd(pathLen)}`;
   process.stdout.write(row("ID", "SCOPE", "PATH") + "\n");
   process.stdout.write(`${"-".repeat(idLen)}  ${"-".repeat(scopeLen)}  ${"-".repeat(pathLen)}
 `);
@@ -5415,6 +6409,17 @@ function printFileTable(files) {
 }
 
 // src/commands/skill.ts
+var SKILL_LOCAL_PLATFORMS = /* @__PURE__ */ new Set(["claude-code", "openclaw", "opencode", "plugin"]);
+function parsePlatforms(raw) {
+  if (raw === "all") return void 0;
+  const values = raw.split(",").map((item) => item.trim()).filter(Boolean);
+  for (const value of values) {
+    if (!SKILL_LOCAL_PLATFORMS.has(value)) {
+      throw new Error(`Invalid platform "${value}". Expected claude-code, openclaw, opencode, plugin, or all.`);
+    }
+  }
+  return values;
+}
 function padEnd(str, len) {
   if (str.length >= len) return str.slice(0, len);
   return str + " ".repeat(len - str.length);
@@ -5475,10 +6480,11 @@ function register6(parent, getIMClient2, _getAPIClient) {
       if (!opts.local) {
         res = await client.im.evolution.installSkill(slug);
       } else {
-        const platforms = opts.platform === "all" ? void 0 : [opts.platform];
+        const platforms = parsePlatforms(opts.platform);
         res = await client.im.evolution.installSkillLocal(slug, {
           platforms,
-          project: opts.project
+          project: Boolean(opts.project),
+          projectRoot: opts.project
         });
       }
       if (opts.json) {
@@ -5622,7 +6628,7 @@ ${result.content}
   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 platforms = parsePlatforms(opts.platform);
       const res = await client.im.evolution.syncSkillsLocal({ platforms });
       if (opts.json) {
         process.stdout.write(JSON.stringify(res, null, 2) + "\n");
@@ -6292,9 +7298,487 @@ function register10(parent, getIMClient2, _getAPIClient) {
   });
 }
 
-// src/daemon.ts
+// src/commands/asset.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
+function resolveWorkspaceId(flag) {
+  if (flag) return flag;
+  if (typeof process !== "undefined" && process.env?.PRISMER_WORKSPACE_ID) {
+    return process.env.PRISMER_WORKSPACE_ID;
+  }
+  return void 0;
+}
+function requireWorkspaceId(flag) {
+  const wsId = resolveWorkspaceId(flag);
+  if (!wsId) {
+    process.stderr.write("Error: --workspace-id is required (or set PRISMER_WORKSPACE_ID env var).\n");
+    process.exit(1);
+  }
+  return wsId;
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const pattern = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${pattern}$`, "i");
+}
+function assetFilename(a) {
+  if (a.filename) return a.filename;
+  const meta = a.metadata;
+  if (meta) {
+    const fn = meta["filename"] ?? meta["fileName"] ?? meta["name"];
+    if (typeof fn === "string") return fn;
+  }
+  return null;
+}
+function formatBytes(n) {
+  if (n == null) return "-";
+  return String(n);
+}
+function register11(parent, getIMClient2, _getAPIClient) {
+  const asset = parent.command("asset").description("Inspect and manage workspace assets (content-addressed)");
+  asset.command("list").description("List assets in a workspace").option("--workspace-id <id>", "workspace id (defaults to PRISMER_WORKSPACE_ID env)").option("--filename <glob>", 'filter by filename glob (client-side, e.g. "design-doc*")').option("--mime <type>", 'filter by MIME type prefix (e.g. "application/pdf")').option("--kind <kind>", "filter by row-level kind (e.g. file, image, sandbox-output)").option("--updated-after <iso>", "filter to assets created/updated after this ISO timestamp").option("--task-id <id>", "filter by source task id").option("-n, --limit <n>", "maximum results to return", "50").option("--json", "output raw JSON response").action(async (opts) => {
+    const wsId = requireWorkspaceId(opts.workspaceId);
+    const client = getIMClient2();
+    try {
+      const limit = Math.min(Math.max(parseInt(opts.limit, 10) || 50, 1), 200);
+      const res = await client.im.assets.list({
+        workspaceId: wsId,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        limit
+      });
+      if (!res.ok) {
+        if (opts.json) process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        else process.stderr.write(`Error: ${res.error?.message || "list failed"}
+`);
+        process.exit(1);
+      }
+      let rows = res.data ?? [];
+      if (opts.filename) {
+        const re = globToRegex(opts.filename);
+        rows = rows.filter((r) => {
+          const fn = assetFilename(r);
+          return fn != null && re.test(fn);
+        });
+      }
+      if (opts.mime) {
+        const m = opts.mime.toLowerCase();
+        rows = rows.filter((r) => (r.mime ?? "").toLowerCase().startsWith(m));
+      }
+      if (opts.updatedAfter) {
+        const after = Date.parse(opts.updatedAfter);
+        if (!Number.isNaN(after)) {
+          rows = rows.filter((r) => {
+            const ts = Date.parse(r.createdAt ?? "");
+            return !Number.isNaN(ts) && ts >= after;
+          });
+        }
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: true, data: rows }, null, 2) + "\n");
+        return;
+      }
+      if (rows.length === 0) {
+        process.stdout.write("No assets found.\n");
+        return;
+      }
+      const idW = 24;
+      const mimeW = 20;
+      const sizeW = 12;
+      const hashW = 16;
+      const header = "ID".padEnd(idW) + "MIME".padEnd(mimeW) + "SIZE".padEnd(sizeW) + "HASH".padEnd(hashW) + "NAME";
+      process.stdout.write(header + "\n");
+      process.stdout.write("-".repeat(idW + mimeW + sizeW + hashW + 20) + "\n");
+      for (const r of rows) {
+        const id = String(r.id).slice(0, idW - 1);
+        const mime = (r.mime ?? "-").slice(0, mimeW - 1);
+        const size = formatBytes(r.sizeBytes).slice(0, sizeW - 1);
+        const hash = (r.contentHash ?? "-").slice(0, 12);
+        const name = assetFilename(r) ?? "";
+        process.stdout.write(
+          id.padEnd(idW) + mime.padEnd(mimeW) + size.padEnd(sizeW) + hash.padEnd(hashW) + name + "\n"
+        );
+      }
+      process.stdout.write(`
+${rows.length} asset(s) listed.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  asset.command("get <assetId>").description("Show full asset metadata (no content)").option("--json", "output raw JSON response").action(async (assetId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.assets.detail(assetId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        if (!res.ok) process.exit(1);
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "get failed"}
+`);
+        process.exit(1);
+      }
+      const a = res.data;
+      process.stdout.write(`ID:           ${a.id}
+`);
+      process.stdout.write(`Workspace:    ${a.workspaceId}
+`);
+      process.stdout.write(`Hash:         ${a.contentHash}
+`);
+      process.stdout.write(`MIME:         ${a.mime ?? "-"}
+`);
+      process.stdout.write(`Size:         ${formatBytes(a.sizeBytes)} bytes
+`);
+      process.stdout.write(`Kind:         ${a.kind}
+`);
+      process.stdout.write(`Storage URI:  ${a.storageUri}
+`);
+      process.stdout.write(`Created:      ${a.createdAt}
+`);
+      const fn = assetFilename(a);
+      if (fn) process.stdout.write(`Filename:     ${fn}
+`);
+      if (a.sourceTaskId) process.stdout.write(`Source Task:  ${a.sourceTaskId}
+`);
+      if (a.sourceAgentImUserId) process.stdout.write(`Source Agent: ${a.sourceAgentImUserId}
+`);
+      if (a.cdnUrl) process.stdout.write(`CDN URL:      ${a.cdnUrl}
+`);
+      if (a.url) process.stdout.write(`Signed URL:   ${a.url} (expires in ${a.expiresIn ?? "?"}s)
+`);
+      if (a.metadata && Object.keys(a.metadata).length > 0) {
+        process.stdout.write(`Metadata:     ${JSON.stringify(a.metadata)}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  asset.command("by-hash <sha256>").description("Look up an asset by content hash (sha256)").option("--workspace-id <id>", "workspace id (defaults to PRISMER_WORKSPACE_ID env)").option("--json", "output raw JSON response").action(async (sha256, opts) => {
+    const wsId = requireWorkspaceId(opts.workspaceId);
+    const client = getIMClient2();
+    try {
+      const res = await client.im.assets.byHash(sha256, wsId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        if (!res.ok) process.exit(1);
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "by-hash failed"}
+`);
+        process.exit(1);
+      }
+      const a = res.data;
+      process.stdout.write(`ID:    ${a.id}
+`);
+      process.stdout.write(`Hash:  ${a.contentHash}
+`);
+      process.stdout.write(`MIME:  ${a.mime ?? "-"}
+`);
+      process.stdout.write(`Size:  ${formatBytes(a.sizeBytes)} bytes
+`);
+      process.stdout.write(`Kind:  ${a.kind}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  asset.command("upload <path>").description("Upload a local file as a workspace asset").option("--workspace-id <id>", "workspace id (defaults to PRISMER_WORKSPACE_ID env)").option("--conversation-id <id>", "pin upload to a conversation (stored in metadata)").option("--kind <kind>", "asset kind label", "user-upload").option("--task-id <id>", "source task id").option("--mime <type>", "override detected MIME type").option("--filename <name>", "override filename").option("--json", "output raw JSON response").action(async (filePath, opts) => {
+    const wsId = requireWorkspaceId(opts.workspaceId);
+    if (!fs2.existsSync(filePath)) {
+      process.stderr.write(`Error: file not found: ${filePath}
+`);
+      process.exit(1);
+    }
+    const client = getIMClient2();
+    try {
+      const metadata = {};
+      if (opts.conversationId) metadata.conversationId = opts.conversationId;
+      if (opts.filename) metadata.filename = opts.filename;
+      const uploadOpts = {
+        workspaceId: wsId,
+        kind: opts.kind ?? "user-upload"
+      };
+      if (opts.taskId) uploadOpts.sourceTaskId = opts.taskId;
+      if (opts.mime) uploadOpts.mimeType = opts.mime;
+      if (opts.filename) uploadOpts.fileName = opts.filename;
+      if (Object.keys(metadata).length > 0) uploadOpts.metadata = metadata;
+      const res = await client.im.assets.upload(filePath, uploadOpts);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        if (!res.ok) process.exit(1);
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "upload failed"}
+`);
+        process.exit(1);
+      }
+      const a = res.data;
+      process.stdout.write(`Uploaded ${path2.basename(filePath)}
+`);
+      process.stdout.write(`  ID:    ${a.id}
+`);
+      process.stdout.write(`  Hash:  ${a.contentHash}
+`);
+      process.stdout.write(`  Size:  ${formatBytes(a.sizeBytes)} bytes
+`);
+      process.stdout.write(`  MIME:  ${a.mime ?? "-"}
+`);
+      process.stdout.write(`  Kind:  ${a.kind}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  asset.command("download <assetId>").description("Download asset bytes (to file or stdout)").option("--out <path>", "destination file (omit to write to stdout)").option("--offset <n>", "byte offset for partial download", parseIntOpt).option("--length <n>", "byte length for partial download", parseIntOpt).action(async (assetId, opts) => {
+    try {
+      const { bytes, truncated, totalSize } = await fetchAssetBytes(
+        getIMClient2(),
+        assetId,
+        opts.offset,
+        opts.length
+      );
+      if (opts.out) {
+        fs2.writeFileSync(opts.out, bytes);
+        const range = describeRange(opts.offset, opts.length, bytes.byteLength);
+        process.stderr.write(
+          `Downloaded ${assetId} -> ${opts.out} (${bytes.byteLength} bytes${range ? `, ${range}` : ""}${truncated ? ", truncated" : ""}${totalSize != null ? `, total=${totalSize}` : ""})
+`
+        );
+      } else {
+        process.stdout.write(bytes);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  asset.command("read <assetId>").description("Read an asset as text (bounded by --offset/--length)").option("--offset <n>", "byte offset for read", parseIntOpt).option("--length <n>", "maximum bytes to read (recommended for large files)", parseIntOpt).option("--force", "read even if MIME is not text-like").action(async (assetId, opts) => {
+    const client = getIMClient2();
+    try {
+      const detailRes = await client.im.assets.detail(assetId);
+      if (!detailRes.ok) {
+        process.stderr.write(`Error: ${detailRes.error?.message || "asset get failed"}
+`);
+        process.exit(1);
+      }
+      const detail = detailRes.data;
+      const mime = (detail.mime ?? "").toLowerCase();
+      const looksTextual = mime.startsWith("text/") || mime === "application/json" || mime === "application/xml" || mime === "application/javascript" || mime === "application/x-yaml" || mime.endsWith("+json") || mime.endsWith("+xml");
+      if (!looksTextual && !opts.force) {
+        process.stderr.write(
+          `Refusing to read non-text asset (mime=${detail.mime ?? "unknown"}). Use --force to override, or use "cloud asset download" for binary content.
+`
+        );
+        process.exit(1);
+      }
+      const { bytes, truncated, totalSize } = await fetchAssetBytes(
+        client,
+        assetId,
+        opts.offset,
+        opts.length
+      );
+      const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+      process.stdout.write(text);
+      if (text.length > 0 && !text.endsWith("\n")) process.stdout.write("\n");
+      const start = opts.offset ?? 0;
+      const end = start + bytes.byteLength;
+      const range = `${start}..${end}`;
+      process.stderr.write(
+        `asset=${detail.id} hash=${detail.contentHash} range=${range} bytes=${bytes.byteLength} truncated=${truncated}${totalSize != null ? ` total=${totalSize}` : ""}
+`
+      );
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  asset.command("sync").description("Refresh the local cache index by re-listing the workspace").option("--workspace-id <id>", "workspace id (defaults to PRISMER_WORKSPACE_ID env)").option("-n, --limit <n>", "maximum results to walk", "200").option("--json", "output raw JSON response").action(async (opts) => {
+    const wsId = requireWorkspaceId(opts.workspaceId);
+    const client = getIMClient2();
+    try {
+      const limit = Math.min(Math.max(parseInt(opts.limit, 10) || 200, 1), 200);
+      const res = await client.im.assets.list({ workspaceId: wsId, limit });
+      if (!res.ok) {
+        if (opts.json) process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        else process.stderr.write(`Error: ${res.error?.message || "sync failed"}
+`);
+        process.exit(1);
+      }
+      const count = (res.data ?? []).length;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify({ ok: true, data: { workspaceId: wsId, count } }, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Synced ${count} asset(s) for workspace ${wsId}.
+`);
+      process.stdout.write(
+        "Note: asset bytes are fetched lazily on first read; this command refreshes metadata only.\n"
+      );
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+function parseIntOpt(value) {
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n) || n < 0) {
+    throw new Error(`expected non-negative integer, got "${value}"`);
+  }
+  return n;
+}
+function describeRange(offset, length, actual) {
+  if (offset == null && length == null) return null;
+  const start = offset ?? 0;
+  const end = start + (actual ?? length ?? 0);
+  return `range=${start}..${end}`;
+}
+async function fetchAssetBytes(client, assetId, offset, length) {
+  const url = client.im.assets.url(assetId);
+  const headers = {};
+  if (offset != null || length != null) {
+    const start = offset ?? 0;
+    const end = length != null ? start + length - 1 : "";
+    headers["Range"] = `bytes=${start}-${end}`;
+  }
+  const resp = await client.fetchAuthed(url, { method: "GET", headers });
+  if (!resp.ok && resp.status !== 206) {
+    let detail = "";
+    try {
+      detail = await resp.text();
+    } catch {
+    }
+    throw new Error(`Asset fetch failed (${resp.status}): ${detail || resp.statusText}`);
+  }
+  const ab = await resp.arrayBuffer();
+  const bytes = new Uint8Array(ab);
+  let totalSize = null;
+  const cr = resp.headers.get("content-range");
+  if (cr) {
+    const m = cr.match(/\/(\d+)$/);
+    if (m) totalSize = Number(m[1]);
+  } else {
+    const cl = resp.headers.get("content-length");
+    if (cl) totalSize = Number(cl);
+  }
+  let truncated = false;
+  if (length != null) {
+    if (totalSize != null) {
+      const start = offset ?? 0;
+      truncated = start + bytes.byteLength < totalSize;
+    } else {
+      truncated = bytes.byteLength >= length;
+    }
+  } else if (offset != null && totalSize != null) {
+    truncated = offset + bytes.byteLength < totalSize;
+  }
+  return { bytes, truncated, totalSize };
+}
+
+// src/commands/approval.ts
+function resolveWorkspaceId2(flag) {
+  if (flag) return flag;
+  if (typeof process !== "undefined" && process.env?.PRISMER_WORKSPACE_ID) {
+    return process.env.PRISMER_WORKSPACE_ID;
+  }
+  return void 0;
+}
+function register12(parent, getIMClient2, _getAPIClient) {
+  const approval = parent.command("approval").description("Submit and manage human approval requests");
+  approval.command("request-human").description("Submit a human approval request and stop the current turn").requiredOption("--action <text>", "one-sentence summary of the gated action").requiredOption("--context <text>", "multi-sentence framing for the human").requiredOption("--risk <text>", "what breaks if approved wrongly; what is reversible").option("--options <opt...>", "explicit choice values (defaults to approve/reject if omitted)").option("--task-id <id>", "task to resume when the human decides").option("--conversation-id <id>", "conversation context for the request").option("--workspace-id <id>", "workspace id (defaults to PRISMER_WORKSPACE_ID env)").option("--category <category>", "approval category label", "human-approval").option("--expires-in <seconds>", "expiration window in seconds (default 24h)", parseIntOpt2).option("--json", "output raw JSON response").action(async (opts) => {
+    if (!opts.conversationId && !opts.taskId) {
+      process.stderr.write(
+        "Error: --conversation-id or --task-id is required (human-approval needs an anchor).\n"
+      );
+      process.exit(1);
+    }
+    const workspaceId = resolveWorkspaceId2(opts.workspaceId);
+    const composedContext = `${opts.context}
+
+Risk: ${opts.risk}`;
+    const optionList = opts.options && opts.options.length > 0 ? opts.options.map((v) => ({ value: v, label: v })) : [
+      { value: "approve", label: "Approve" },
+      { value: "reject", label: "Reject" }
+    ];
+    const metadata = {
+      risk: opts.risk,
+      source: "cli:prismer-approval-request-human"
+    };
+    const body = {
+      category: opts.category,
+      title: opts.action,
+      context: composedContext,
+      options: optionList,
+      metadata
+    };
+    if (workspaceId) body.workspaceId = workspaceId;
+    if (opts.conversationId) body.conversationId = opts.conversationId;
+    if (opts.taskId) body.taskId = opts.taskId;
+    if (opts.expiresIn) body.expiresInSeconds = opts.expiresIn;
+    try {
+      const client = getIMClient2();
+      const res = await client.im.request(
+        "POST",
+        "/api/im/approvals",
+        body
+      );
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+      }
+      if (!res.ok) {
+        if (!opts.json) {
+          process.stderr.write(`Error: ${res.error?.message || "approval submission failed"}
+`);
+        }
+        process.exit(1);
+      }
+      const data = res.data;
+      const summary = {
+        approvalId: data.id,
+        status: data.status ?? "pending",
+        expiresAt: data.expiresAt ?? null
+      };
+      if (!opts.json) {
+        process.stdout.write(JSON.stringify(summary) + "\n");
+      }
+      process.stderr.write(
+        `Submitted approval request ${data.id}. Stopping this turn.
+`
+      );
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+function parseIntOpt2(value) {
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n) || n <= 0) {
+    throw new Error(`expected positive integer, got "${value}"`);
+  }
+  return n;
+}
+
+// src/daemon.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 var import_path = require("path");
 var os = __toESM(require("os"));
 var import_os = require("os");
@@ -6302,22 +7786,22 @@ var http = __toESM(require("http"));
 var import_http = require("http");
 var import_child_process = require("child_process");
 var TOML = __toESM(require("@iarna/toml"));
-var CONFIG_DIR = path2.join(os.homedir(), ".prismer");
-var CONFIG_PATH = path2.join(CONFIG_DIR, "config.toml");
-var PID_PATH = path2.join(CONFIG_DIR, "daemon.pid");
-var PORT_PATH = path2.join(CONFIG_DIR, "daemon.port");
-var CACHE_DIR = path2.join(CONFIG_DIR, "cache");
-var EVOLUTION_CACHE_PATH = path2.join(CACHE_DIR, "evolution.json");
-var OUTBOX_PATH = path2.join(CACHE_DIR, "outbox.json");
+var CONFIG_DIR = path3.join(os.homedir(), ".prismer");
+var CONFIG_PATH = path3.join(CONFIG_DIR, "config.toml");
+var PID_PATH = path3.join(CONFIG_DIR, "daemon.pid");
+var PORT_PATH = path3.join(CONFIG_DIR, "daemon.port");
+var CACHE_DIR = path3.join(CONFIG_DIR, "cache");
+var EVOLUTION_CACHE_PATH = path3.join(CACHE_DIR, "evolution.json");
+var OUTBOX_PATH = path3.join(CACHE_DIR, "outbox.json");
 var SYNC_INTERVAL_MS = 6e4;
 var FLUSH_INTERVAL_MS = 3e4;
 var API_TIMEOUT_MS = 1e4;
 var EVENTS_FILE = (0, import_path.join)(CACHE_DIR, "events.json");
 var MAX_EVENTS = 1e3;
 function loadConfig() {
-  if (!fs2.existsSync(CONFIG_PATH)) return null;
+  if (!fs3.existsSync(CONFIG_PATH)) return null;
   try {
-    const raw = fs2.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = fs3.readFileSync(CONFIG_PATH, "utf-8");
     const parsed = TOML.parse(raw);
     const apiKey = parsed?.default?.api_key || "";
     const baseUrl = parsed?.default?.base_url || "https://prismer.cloud";
@@ -6328,13 +7812,13 @@ function loadConfig() {
   }
 }
 function ensureCacheDir() {
-  if (!fs2.existsSync(CACHE_DIR)) {
-    fs2.mkdirSync(CACHE_DIR, { recursive: true });
+  if (!fs3.existsSync(CACHE_DIR)) {
+    fs3.mkdirSync(CACHE_DIR, { recursive: true });
   }
 }
 function loadEvents() {
   try {
-    return JSON.parse(fs2.readFileSync(EVENTS_FILE, "utf-8"));
+    return JSON.parse(fs3.readFileSync(EVENTS_FILE, "utf-8"));
   } catch {
     return [];
   }
@@ -6343,7 +7827,7 @@ function appendEvent(event) {
   const events = loadEvents();
   events.push(event);
   if (events.length > MAX_EVENTS) events.splice(0, events.length - MAX_EVENTS);
-  fs2.writeFileSync(EVENTS_FILE, JSON.stringify(events), { encoding: "utf-8", mode: 384 });
+  fs3.writeFileSync(EVENTS_FILE, JSON.stringify(events), { encoding: "utf-8", mode: 384 });
 }
 function emitSyncEvent(genesCount) {
   if (genesCount > 0) {
@@ -6358,9 +7842,9 @@ function emitSyncEvent(genesCount) {
   }
 }
 function readPid() {
-  if (!fs2.existsSync(PID_PATH)) return null;
+  if (!fs3.existsSync(PID_PATH)) return null;
   try {
-    const raw = fs2.readFileSync(PID_PATH, "utf-8").trim();
+    const raw = fs3.readFileSync(PID_PATH, "utf-8").trim();
     const pid = parseInt(raw, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -6368,9 +7852,9 @@ function readPid() {
   }
 }
 function readPort() {
-  if (!fs2.existsSync(PORT_PATH)) return null;
+  if (!fs3.existsSync(PORT_PATH)) return null;
   try {
-    const raw = fs2.readFileSync(PORT_PATH, "utf-8").trim();
+    const raw = fs3.readFileSync(PORT_PATH, "utf-8").trim();
     const port = parseInt(raw, 10);
     return isNaN(port) ? null : port;
   } catch {
@@ -6387,24 +7871,24 @@ function isProcessRunning(pid) {
 }
 function writePid(pid) {
   ensureCacheDir();
-  if (!fs2.existsSync(CONFIG_DIR)) {
-    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs3.existsSync(CONFIG_DIR)) {
+    fs3.mkdirSync(CONFIG_DIR, { recursive: true });
   }
-  fs2.writeFileSync(PID_PATH, String(pid), { encoding: "utf-8", mode: 384 });
+  fs3.writeFileSync(PID_PATH, String(pid), { encoding: "utf-8", mode: 384 });
 }
 function writePort(port) {
-  if (!fs2.existsSync(CONFIG_DIR)) {
-    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs3.existsSync(CONFIG_DIR)) {
+    fs3.mkdirSync(CONFIG_DIR, { recursive: true });
   }
-  fs2.writeFileSync(PORT_PATH, String(port), { encoding: "utf-8", mode: 384 });
+  fs3.writeFileSync(PORT_PATH, String(port), { encoding: "utf-8", mode: 384 });
 }
 function cleanupPidFiles() {
   try {
-    if (fs2.existsSync(PID_PATH)) fs2.unlinkSync(PID_PATH);
+    if (fs3.existsSync(PID_PATH)) fs3.unlinkSync(PID_PATH);
   } catch {
   }
   try {
-    if (fs2.existsSync(PORT_PATH)) fs2.unlinkSync(PORT_PATH);
+    if (fs3.existsSync(PORT_PATH)) fs3.unlinkSync(PORT_PATH);
   } catch {
   }
 }
@@ -6420,16 +7904,16 @@ async function fetchWithTimeout(url, options, timeoutMs = API_TIMEOUT_MS) {
 async function runDaemonProcess() {
   const cfg = loadConfig();
   if (!cfg) {
-    process.stderr.write('[prismer-daemon] No config found. Run "prismer setup" first.\n');
+    process.stderr.write('[cloud-daemon] No config found. Run "cloud setup" first.\n');
     process.exit(1);
   }
   ensureCacheDir();
   let lastSync = 0;
   let syncCount = 0;
   let evolutionCursor = 0;
-  if (fs2.existsSync(EVOLUTION_CACHE_PATH)) {
+  if (fs3.existsSync(EVOLUTION_CACHE_PATH)) {
     try {
-      const cached = JSON.parse(fs2.readFileSync(EVOLUTION_CACHE_PATH, "utf-8"));
+      const cached = JSON.parse(fs3.readFileSync(EVOLUTION_CACHE_PATH, "utf-8"));
       if (typeof cached?.cursor === "number") evolutionCursor = cached.cursor;
     } catch {
     }
@@ -6437,9 +7921,9 @@ async function runDaemonProcess() {
   const server = (0, import_http.createServer)((req, res) => {
     if (req.method === "GET" && req.url === "/health") {
       let outboxSize = 0;
-      if (fs2.existsSync(OUTBOX_PATH)) {
+      if (fs3.existsSync(OUTBOX_PATH)) {
         try {
-          const entries = JSON.parse(fs2.readFileSync(OUTBOX_PATH, "utf-8"));
+          const entries = JSON.parse(fs3.readFileSync(OUTBOX_PATH, "utf-8"));
           if (Array.isArray(entries)) outboxSize = entries.length;
         } catch {
         }
@@ -6502,7 +7986,7 @@ async function runDaemonProcess() {
         }
         ensureCacheDir();
         const pulled = data?.data || data;
-        fs2.writeFileSync(
+        fs3.writeFileSync(
           EVOLUTION_CACHE_PATH,
           JSON.stringify({ cursor: evolutionCursor, lastSync, data: pulled }, null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -6513,10 +7997,10 @@ async function runDaemonProcess() {
     }
   };
   const doOutboxFlush = async () => {
-    if (!fs2.existsSync(OUTBOX_PATH)) return;
+    if (!fs3.existsSync(OUTBOX_PATH)) return;
     let entries = [];
     try {
-      entries = JSON.parse(fs2.readFileSync(OUTBOX_PATH, "utf-8"));
+      entries = JSON.parse(fs3.readFileSync(OUTBOX_PATH, "utf-8"));
       if (!Array.isArray(entries) || entries.length === 0) return;
     } catch {
       return;
@@ -6537,7 +8021,7 @@ async function runDaemonProcess() {
         }
       );
       if (res.ok) {
-        fs2.writeFileSync(OUTBOX_PATH, "[]", { encoding: "utf-8", mode: 384 });
+        fs3.writeFileSync(OUTBOX_PATH, "[]", { encoding: "utf-8", mode: 384 });
       }
     } catch {
     }
@@ -6567,7 +8051,7 @@ async function startDaemon() {
   cleanupPidFiles();
   const cfg = loadConfig();
   if (!cfg) {
-    console.error('No API key found. Run "prismer setup" first.');
+    console.error('No API key found. Run "cloud setup" first.');
     process.exit(1);
   }
   if (process.env["PRISMER_DAEMON"] === "1") {
@@ -6655,7 +8139,7 @@ function resolveNpxPath() {
   } catch {
     for (const p of ["/usr/local/bin/npx", "/opt/homebrew/bin/npx", `${(0, import_os.homedir)()}/.nvm/current/bin/npx`]) {
       try {
-        fs2.accessSync(p);
+        fs3.accessSync(p);
         return p;
       } catch {
       }
@@ -6697,8 +8181,8 @@ function installLaunchd() {
   <string>${(0, import_path.join)((0, import_os.homedir)(), ".prismer", "daemon.stderr.log")}</string>
 </dict>
 </plist>`;
-  fs2.mkdirSync((0, import_path.dirname)(plistPath), { recursive: true });
-  fs2.writeFileSync(plistPath, plist, { mode: 384 });
+  fs3.mkdirSync((0, import_path.dirname)(plistPath), { recursive: true });
+  fs3.writeFileSync(plistPath, plist, { mode: 384 });
   try {
     (0, import_child_process.execSync)(`launchctl load ${plistPath}`, { stdio: "pipe" });
     console.log("[prismer] Daemon service installed and started (launchd)");
@@ -6714,7 +8198,7 @@ function uninstallLaunchd() {
   } catch {
   }
   try {
-    fs2.unlinkSync(plistPath);
+    fs3.unlinkSync(plistPath);
   } catch {
   }
   console.log("[prismer] Daemon service uninstalled (launchd)");
@@ -6739,8 +8223,8 @@ RestartSec=10
 [Install]
 WantedBy=default.target
 `;
-  fs2.mkdirSync(serviceDir, { recursive: true });
-  fs2.writeFileSync(servicePath, unit, { mode: 420 });
+  fs3.mkdirSync(serviceDir, { recursive: true });
+  fs3.writeFileSync(servicePath, unit, { mode: 420 });
   try {
     (0, import_child_process.execSync)("systemctl --user daemon-reload", { stdio: "pipe" });
     (0, import_child_process.execSync)("systemctl --user enable prismer-daemon", { stdio: "pipe" });
@@ -6763,7 +8247,7 @@ function uninstallSystemd() {
   }
   const servicePath = (0, import_path.join)((0, import_os.homedir)(), ".config", "systemd", "user", "prismer-daemon.service");
   try {
-    fs2.unlinkSync(servicePath);
+    fs3.unlinkSync(servicePath);
   } catch {
   }
   try {
@@ -6779,7 +8263,7 @@ function installDaemonService() {
   } else if (platform === "linux") {
     installSystemd();
   } else {
-    console.log(`Daemon auto-start not supported on ${platform}. Use: prismer daemon start`);
+    console.log(`Daemon auto-start not supported on ${platform}. Use: cloud daemon start`);
   }
 }
 function uninstallDaemonService() {
@@ -6803,26 +8287,39 @@ if (process.env["PRISMER_DAEMON"] === "1") {
 // src/cli.ts
 var cliVersion = "1.7.2";
 try {
-  const pkgPath = path3.join(__dirname, "..", "package.json");
-  const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
+  const pkgPath = path4.join(__dirname, "..", "package.json");
+  const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf8"));
   cliVersion = pkg.version || cliVersion;
 } catch {
 }
-var CONFIG_DIR2 = path3.join(os2.homedir(), ".prismer");
-var CONFIG_PATH2 = path3.join(CONFIG_DIR2, "config.toml");
+var CONFIG_DIR2 = process.env.PRISMER_HOME ? path4.resolve(process.env.PRISMER_HOME) : path4.join(os2.homedir(), ".prismer");
+var CONFIG_PATH2 = path4.join(CONFIG_DIR2, "config.toml");
 function ensureConfigDir() {
-  if (!fs3.existsSync(CONFIG_DIR2)) {
-    fs3.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs4.existsSync(CONFIG_DIR2)) {
+    fs4.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
 }
 function readConfig() {
-  if (!fs3.existsSync(CONFIG_PATH2)) return {};
-  const raw = fs3.readFileSync(CONFIG_PATH2, "utf-8");
-  return TOML2.parse(raw);
+  if (!fs4.existsSync(CONFIG_PATH2)) return {};
+  const raw = fs4.readFileSync(CONFIG_PATH2, "utf-8");
+  const parsed = TOML2.parse(raw);
+  const flatApiKey = parsed.api_key;
+  const flatBaseUrl = parsed.cloud_api_base ?? parsed.base_url;
+  const flatEnv = parsed.environment;
+  if (flatApiKey || flatBaseUrl || flatEnv) {
+    parsed.default = {
+      ...parsed.default ?? {},
+      // Explicit [default].api_key wins; flat is the fallback (runtime-written).
+      api_key: parsed.default?.api_key ?? flatApiKey,
+      base_url: parsed.default?.base_url ?? flatBaseUrl,
+      environment: parsed.default?.environment ?? flatEnv
+    };
+  }
+  return parsed;
 }
 function writeConfig(config) {
   ensureConfigDir();
-  fs3.writeFileSync(CONFIG_PATH2, TOML2.stringify(config), { encoding: "utf-8", mode: 384 });
+  fs4.writeFileSync(CONFIG_PATH2, TOML2.stringify(config), { encoding: "utf-8", mode: 384 });
 }
 function setNestedValue(obj, dotPath, value) {
   const parts = dotPath.split(".");
@@ -6836,20 +8333,24 @@ function setNestedValue(obj, dotPath, value) {
 }
 function getIMClient() {
   const cfg = readConfig();
-  const token = cfg?.auth?.im_token;
-  if (!token) {
-    error('No IM token. Run "prismer setup --agent" or "prismer register <username>" first.');
-    process.exit(1);
-  }
   const env = cfg?.default?.environment || "production";
   const baseUrl = cfg?.default?.base_url || "";
-  return new PrismerClient({ apiKey: token, environment: env, ...baseUrl ? { baseUrl } : {} });
+  const imToken = cfg?.auth?.im_token;
+  if (imToken) {
+    return new PrismerClient({ apiKey: imToken, environment: env, ...baseUrl ? { baseUrl } : {} });
+  }
+  const apiKey = cfg?.default?.api_key;
+  if (!apiKey) {
+    errorLine('No credentials. Run "cloud setup" first (or "cloud setup --agent" / "cloud register <username>" for IM-JWT path).');
+    process.exit(1);
+  }
+  return new PrismerClient({ apiKey, environment: env, ...baseUrl ? { baseUrl } : {} });
 }
 function getAPIClient() {
   const cfg = readConfig();
   const apiKey = cfg?.default?.api_key;
   if (!apiKey) {
-    error('No API key. Run "prismer setup" to sign in and get your key.');
+    errorLine('No API key. Run "cloud setup" to sign in and get your key.');
     process.exit(1);
   }
   const env = cfg?.default?.environment || "production";
@@ -6857,15 +8358,15 @@ function getAPIClient() {
   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.name("cloud").description("Prismer Cloud SDK CLI").version(cliVersion);
 async function verifyAndSaveKey(config, apiKey) {
   if (!apiKey) {
-    error("No key provided.");
+    errorLine("No key provided.");
     process.exit(1);
   }
   if (!apiKey.startsWith("sk-prismer-")) {
-    error("Invalid key format. API keys start with sk-prismer-");
-    dim2("  Get your key at: https://prismer.cloud/setup");
+    errorLine("Invalid key format. API keys start with sk-prismer-");
+    dim("  Get your key at: https://prismer.cloud/setup");
     process.exit(1);
   }
   const baseUrl = config.default?.base_url || "https://prismer.cloud";
@@ -6874,8 +8375,8 @@ async function verifyAndSaveKey(config, apiKey) {
       headers: { Authorization: `Bearer ${apiKey}` }
     });
     if (res.status === 401) {
-      error("API key is invalid or expired.");
-      dim2("  Get a new key at: https://prismer.cloud/setup");
+      errorLine("API key is invalid or expired.");
+      dim("  Get a new key at: https://prismer.cloud/setup");
       process.exit(1);
     }
     success("API key verified");
@@ -6892,7 +8393,7 @@ async function verifyAndSaveKey(config, apiKey) {
   try {
     installDaemonService();
   } catch {
-    dim2("Daemon auto-start setup skipped. Run manually: prismer daemon install");
+    dim("Daemon auto-start setup skipped. Run manually: cloud daemon install");
   }
 }
 function openBrowser(url) {
@@ -6919,8 +8420,8 @@ async function runSetup(opts, apiKey) {
     const masked = config.default.api_key.slice(0, 12) + "..." + config.default.api_key.slice(-4);
     success(`Already configured: ${masked}`);
     console.log("");
-    dim2("  To reconfigure, run: prismer setup --force");
-    dim2("  To check status:     prismer status");
+    dim("  To reconfigure, run: cloud setup --force");
+    dim("  To check status:     cloud status");
     return;
   }
   if (apiKey) {
@@ -6930,7 +8431,7 @@ async function runSetup(opts, apiKey) {
   if (opts.agent) {
     if (!opts.force && config.auth?.im_token) {
       success("Already registered as agent (IM token exists).");
-      dim2("  For API key access, run: prismer setup");
+      dim("  For API key access, run: cloud setup");
       return;
     }
     const username = `agent-${Date.now().toString(36)}`;
@@ -6953,10 +8454,10 @@ async function runSetup(opts, apiKey) {
         "User ID": config.auth.im_user_id || ""
       });
       console.log("");
-      info("For full API access, sign in: prismer setup");
+      info("For full API access, sign in: cloud setup");
     } catch (err) {
-      error(`Agent registration failed: ${err.message}`);
-      dim2("  Try signing in instead: prismer setup");
+      errorLine(`Agent registration failed: ${err.message}`);
+      dim("  Try signing in instead: cloud setup");
       process.exit(1);
     }
     return;
@@ -6964,7 +8465,7 @@ async function runSetup(opts, apiKey) {
   if (opts.manual) {
     const setupUrl = `${baseUrl}/setup?utm_source=cli&utm_medium=manual`;
     info("Opening browser to sign in...");
-    dim2(`  ${setupUrl}`);
+    dim(`  ${setupUrl}`);
     console.log("");
     openBrowser(setupUrl);
     info("After signing in, copy the API key from the page and paste it below.");
@@ -6974,7 +8475,7 @@ async function runSetup(opts, apiKey) {
     rl.question("Paste your API key: ", (key) => {
       rl.close();
       verifyAndSaveKey(config, key.trim()).catch((err) => {
-        error(`Setup failed: ${err.message}`);
+        errorLine(`Setup failed: ${err.message}`);
         process.exit(1);
       });
     });
@@ -7021,16 +8522,16 @@ async function runSetup(opts, apiKey) {
     console.log("");
     openBrowser(setupUrl);
     info("Waiting for authentication...");
-    dim2("  (If the browser didn't open, visit this URL manually:)");
-    dim2(`  ${setupUrl}`);
+    dim("  (If the browser didn't open, visit this URL manually:)");
+    dim(`  ${setupUrl}`);
     console.log("");
     setTimeout(() => {
       if (!resolved) {
-        error("Timed out waiting for authentication (5 min).");
+        errorLine("Timed out waiting for authentication (5 min).");
         console.log("");
-        dim2("  Alternatives:");
-        dim2("    prismer setup --manual    Paste key manually");
-        dim2("    prismer setup --agent     Register as agent (free credits, no browser)");
+        dim("  Alternatives:");
+        dim("    cloud setup --manual    Paste key manually");
+        dim("    cloud setup --agent     Register as agent (free credits, no browser)");
         server.close();
         process.exit(1);
       }
@@ -7040,8 +8541,8 @@ async function runSetup(opts, apiKey) {
 program.command("setup [api-key]").description("Set up Prismer \u2014 sign in via browser, register as agent, or provide your API key").option("--manual", "Paste API key manually instead of browser auto-flow").option("--agent", "Register as agent with free credits (no browser, for CI/scripts)").option("--force", "Reconfigure even if already set up").action(async (apiKey, opts) => {
   await runSetup(opts, apiKey);
 });
-program.command("init [api-key]").description('Alias for "prismer setup" (deprecated, use setup instead)').option("--manual", "Paste API key manually").option("--agent", "Register as agent with free credits").option("--force", "Reconfigure even if already set up").action(async (apiKey, opts) => {
-  warn('"prismer init" is deprecated. Use "prismer setup" instead.');
+program.command("init [api-key]").description('Alias for "cloud 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) => {
+  warn('"cloud init" is deprecated. Use "cloud setup" instead.');
   console.log("");
   await runSetup(opts, apiKey);
 });
@@ -7049,7 +8550,7 @@ program.command("register <username>").description("Register an IM identity and
   const config = readConfig();
   const apiKey = config.default?.api_key;
   if (!apiKey) {
-    error('No API key. Run "prismer setup" first.');
+    errorLine('No API key. Run "cloud setup" first.');
     process.exit(1);
   }
   const client = new PrismerClient({
@@ -7069,7 +8570,7 @@ program.command("register <username>").description("Register an IM identity and
   try {
     const result = await client.im.account.register(registerOpts);
     if (!result.ok || !result.data) {
-      error(`Registration failed: ${result.error?.message || "Unknown error"}`);
+      errorLine(`Registration failed: ${result.error?.message || "Unknown error"}`);
       process.exit(1);
     }
     const data = result.data;
@@ -7087,9 +8588,9 @@ program.command("register <username>").description("Register an IM identity and
       "Role": data.role,
       "New": String(data.isNew)
     });
-    dim2("  Token stored in ~/.prismer/config.toml");
+    dim("  Token stored in ~/.prismer/config.toml");
   } catch (err) {
-    error(`Registration failed: ${err instanceof Error ? err.message : String(err)}`);
+    errorLine(`Registration failed: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
 });
@@ -7146,16 +8647,16 @@ program.command("status").description("Show current config and live info").actio
       warn(`Could not fetch live info: ${me.error?.message || "unknown error"}`);
     }
   } else {
-    dim2("  IM Token: (not registered)");
+    dim("  IM Token: (not registered)");
   }
 });
 var configCmd = program.command("config").description("Manage config file");
 configCmd.command("show").description("Print config file").action(() => {
-  if (!fs3.existsSync(CONFIG_PATH2)) {
-    warn('No config file. Run "prismer setup" to create one.');
+  if (!fs4.existsSync(CONFIG_PATH2)) {
+    warn('No config file. Run "cloud setup" to create one.');
     return;
   }
-  console.log(fs3.readFileSync(CONFIG_PATH2, "utf-8"));
+  console.log(fs4.readFileSync(CONFIG_PATH2, "utf-8"));
 });
 configCmd.command("set <key> <value>").description("Set a config value (e.g. default.base_url)").action((key, value) => {
   const config = readConfig();
@@ -7172,7 +8673,7 @@ tokenCmd.command("refresh").description("Refresh IM JWT token").option("--json",
     return;
   }
   if (!res.ok) {
-    error(`Token refresh failed: ${JSON.stringify(res.error)}`);
+    errorLine(`Token refresh failed: ${JSON.stringify(res.error)}`);
     process.exit(1);
   }
   const data = res.data;
@@ -7197,12 +8698,44 @@ register7(program, getIMClient, getAPIClient);
 register8(program, getIMClient, getAPIClient);
 register9(program, getIMClient, getAPIClient);
 register10(program, getIMClient, getAPIClient);
-program.command("send").description("Send a direct message (shortcut for: im send)").argument("<user-id>", "Target user/agent ID").argument("<message>", "Message content").option("-t, --type <type>", "Message type: text, markdown, code, etc.", "text").option("--reply-to <id>", "Reply to a message ID").option("--json", "JSON output").action(async (userId, message, opts) => {
+register11(program, getIMClient, getAPIClient);
+register12(program, getIMClient, getAPIClient);
+program.command("send").description("Send a direct message (shortcut for: im send)").argument("<user-id-or-username>", "Target user/agent IM user ID (or username with --by-username)").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("--conversation-id <id>", "Pin message to a specific conversation/session").option("--asset-id <id>", "Attach a previously uploaded asset (treats type as file)").option("--by-username", "Treat the first argument as a username; resolve to imUserId first").option("--json", "JSON output").action(async (target, message, opts) => {
   const client = getIMClient();
+  let userId = target;
+  if (opts.byUsername) {
+    const discoverRes = await client.im.contacts.discover();
+    if (!discoverRes.ok || !Array.isArray(discoverRes.data)) {
+      errorLine(`Could not resolve username "${target}" \u2014 discover failed.`);
+      process.exit(1);
+    }
+    const needle = target.trim().toLowerCase().replace(/^@/, "");
+    const match = discoverRes.data.find((u) => {
+      const vals = [u.username, u.displayName, u.userId].map(
+        (v) => typeof v === "string" ? v.trim().toLowerCase() : ""
+      );
+      return vals.includes(needle);
+    });
+    if (!match?.userId) {
+      errorLine(`Could not resolve username "${target}" to an IM user.`);
+      process.exit(1);
+    }
+    userId = match.userId;
+  }
   const sendOpts = {};
   if (opts.type && opts.type !== "text") sendOpts.type = opts.type;
   if (opts.replyTo) sendOpts.parentId = opts.replyTo;
+  if (opts.assetId) {
+    if (!opts.type || opts.type === "text") sendOpts.type = "file";
+    sendOpts.attachments = [{ kind: "asset", assetId: opts.assetId, role: "attachment" }];
+  }
+  if (opts.conversationId) {
+    sendOpts.metadata = { ...sendOpts.metadata ?? {}, conversationId: opts.conversationId };
+  }
   const res = await withSpinner("Sending message", async () => {
+    if (opts.conversationId) {
+      return client.im.messages.send(opts.conversationId, message, sendOpts);
+    }
     return client.im.direct.send(userId, message, sendOpts);
   });
   if (opts.json) {
@@ -7210,7 +8743,7 @@ program.command("send").description("Send a direct message (shortcut for: im sen
     return;
   }
   if (!res.ok) {
-    error(`Send failed: ${JSON.stringify(res.error)}`);
+    errorLine(`Send failed: ${JSON.stringify(res.error)}`);
     process.exit(1);
   }
   success(`Message sent (conversation: ${res.data?.conversationId})`);
@@ -7228,7 +8761,7 @@ program.command("load").description("Load URL(s) \u2192 compressed HQCC (shortcu
     return;
   }
   if (!res.success) {
-    error(res.error?.message || "Load failed");
+    errorLine(res.error?.message || "Load failed");
     process.exit(1);
   }
   const results = res.results || (res.result ? [res.result] : []);
@@ -7256,7 +8789,7 @@ program.command("search").description("Search web content (shortcut for: context
     return;
   }
   if (!res.success) {
-    error(res.error?.message || "Search failed");
+    errorLine(res.error?.message || "Search failed");
     process.exit(1);
   }
   const results = res.results || [];
@@ -7274,7 +8807,7 @@ program.command("search").description("Search web content (shortcut for: context
     const r = results[i];
     if (r.hqcc) {
       console.log("");
-      dim2(`  ${i + 1}. ${r.hqcc.substring(0, 200)}`);
+      dim(`  ${i + 1}. ${r.hqcc.substring(0, 200)}`);
     }
   }
 });
@@ -7288,7 +8821,7 @@ program.command("parse").description("Parse a document via OCR (shortcut for: pa
     return;
   }
   if (!res.success) {
-    error(res.error?.message || "Parse failed");
+    errorLine(res.error?.message || "Parse failed");
     process.exit(1);
   }
   if (res.taskId) {
@@ -7297,7 +8830,7 @@ program.command("parse").description("Parse a document via OCR (shortcut for: pa
       "Status": res.status || "processing"
     });
     console.log("");
-    dim2(`  Check: prismer parse-status ${res.taskId}`);
+    dim(`  Check: cloud parse-status ${res.taskId}`);
   } else if (res.document) {
     success("Parse complete");
     const content = res.document.markdown || res.document.text || JSON.stringify(res.document, null, 2);
@@ -7327,27 +8860,50 @@ program.command("parse-result").description("Get parse result").argument("<task-
     return;
   }
   if (!res.success) {
-    error(res.error?.message || "Not ready");
+    errorLine(res.error?.message || "Not ready");
     process.exit(1);
   }
   success("Parse result ready");
   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) => {
+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("--layer <layer>", "Alias for --scope (memory | cache | evolution | all)").option("--strategy <strategy>", "Recall strategy: keyword | llm | hybrid (uses POST /recall when set)").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;
+  let scope = opts.layer || opts.scope || "all";
+  if (scope === "context") scope = "cache";
+  const validStrategies = ["keyword", "llm", "hybrid"];
+  if (opts.strategy && !validStrategies.includes(opts.strategy)) {
+    errorLine(`Invalid --strategy "${opts.strategy}". Use one of: ${validStrategies.join(", ")}.`);
+    process.exit(1);
+  }
   const res = await withSpinner(`Recalling: ${query}`, async () => {
-    return client.im.memory._r("GET", "/api/im/recall", void 0, params);
+    if (opts.strategy) {
+      return client.im.request(
+        "POST",
+        "/api/im/recall",
+        {
+          query,
+          strategy: opts.strategy,
+          scope,
+          maxResults: opts.limit ? parseInt(opts.limit, 10) : void 0
+        }
+      );
+    }
+    const params = { q: query, scope };
+    if (opts.limit) params.limit = String(opts.limit);
+    return client.im.request(
+      "GET",
+      "/api/im/recall",
+      void 0,
+      params
+    );
   });
   if (opts.json) {
     console.log(JSON.stringify(res, null, 2));
     return;
   }
   if (!res.ok) {
-    error(`Recall failed: ${JSON.stringify(res.error)}`);
+    errorLine(`Recall failed: ${JSON.stringify(res.error)}`);
     process.exit(1);
   }
   const data = res.data || [];
@@ -7356,22 +8912,27 @@ program.command("recall").description("Search across memory, cache, and evolutio
     return;
   }
   const rows = data.map((item) => [
-    (item.source || "").toUpperCase(),
-    item.title || "?",
+    (item.source || item.memoryType || "").toUpperCase(),
+    item.title || item.path || "?",
     (item.score || 0).toFixed(2)
   ]);
   table(["Source", "Title", "Score"], rows);
   for (const item of data) {
-    if (item.snippet) {
-      dim2(`  ${item.snippet.substring(0, 200)}`);
+    const snippet = item.snippet || item.content;
+    if (snippet) {
+      dim(`  ${String(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) => {
+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("--online-only", "Only return agents currently online").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;
+  if (opts.onlineOnly) {
+    discoverOpts.status = "online";
+    discoverOpts.onlineOnly = "true";
+  }
   const res = await withSpinner("Discovering agents", async () => {
     return client.im.contacts.discover(discoverOpts);
   });
@@ -7380,7 +8941,7 @@ program.command("discover").description("Discover available agents (shortcut for
     return;
   }
   if (!res.ok) {
-    error(`Discovery failed: ${JSON.stringify(res.error)}`);
+    errorLine(`Discovery failed: ${JSON.stringify(res.error)}`);
     process.exit(1);
   }
   const agents = res.data || [];
@@ -7414,12 +8975,18 @@ program.command("daemon <action>").description("Manage background sync daemon (s
       uninstallDaemonService();
       break;
     default:
-      error(`Unknown daemon action: ${action}. Use: start, stop, status, install, uninstall`);
+      errorLine(`Unknown daemon action: ${action}. Use: start, stop, status, install, uninstall`);
       process.exit(1);
   }
 });
-displayBanner();
-program.parse(process.argv);
+var _head = process.argv.slice(0, 2);
+var _tail = process.argv.slice(2);
+var { mode: _mode, color: _color, restArgv: _restArgv } = applyCommonFlags(_tail);
+setUI(new UI({ mode: _mode, color: _color }));
+if (_mode === "pretty") {
+  displayBanner();
+}
+program.parse([..._head, ..._restArgv]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getAPIClient,