@prismer/sdk 1.8.0 → 1.8.2

package/dist/cli.mjs

@@ -0,0 +1,3838 @@
+import {
+  PrismerClient,
+  __require
+} from "./chunk-VSAVCMMZ.mjs";
+
+// src/cli.ts
+import { Command } from "commander";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+import * as TOML2 from "@iarna/toml";
+
+// src/ui.ts
+import * as pc from "picocolors";
+import * as clack from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+var isTTY = !!process.stdout.isTTY || !!process.env.FORCE_COLOR;
+function displayBanner() {
+  if (!isTTY) return;
+  let iconPath;
+  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();
+  } catch {
+  }
+}
+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));
+}
+async function withSpinner(message, fn) {
+  if (!isTTY) {
+    return fn();
+  }
+  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;
+  }
+}
+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);
+  }
+  for (const row of rows) {
+    const line = headers.map((_, i) => (row[i] || "").padEnd(widths[i] + PAD)).join("");
+    console.log(line);
+  }
+}
+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}`);
+  }
+}
+
+// src/commands/im.ts
+function register(parent, getIMClient2, _getAPIClient) {
+  const im = parent.command("im").description("IM messaging, groups, conversations, and credits");
+  im.command("send <user-id> <message>").description("Send a direct message to a user").option("-t, --type <type>", "Message type: text, markdown, code, file, etc.", "text").option("--reply-to <msg-id>", "Reply to a specific message ID (parentId)").option("--json", "Output raw JSON response").action(async (userId, message, opts) => {
+    const client = getIMClient2();
+    try {
+      const sendOpts = {
+        type: opts.type
+      };
+      if (opts.replyTo) sendOpts.parentId = opts.replyTo;
+      const res = await client.im.direct.send(userId, message, sendOpts);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Message sent (conversationId: ${res.data?.conversationId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("messages <user-id>").description("View direct message history with a user").option("-n, --limit <n>", "Max number of messages to fetch", "20").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.direct.getMessages(userId, { limit: parseInt(opts.limit, 10) });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const msgs = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(msgs, null, 2) + "\n");
+        return;
+      }
+      if (msgs.length === 0) {
+        process.stdout.write("No messages.\n");
+        return;
+      }
+      for (const m of msgs) {
+        const ts = m.createdAt ? new Date(m.createdAt).toLocaleString() : "";
+        process.stdout.write(`[${ts}] ${m.senderId || "?"}: ${m.content}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("edit <conversation-id> <message-id> <content>").description("Edit an existing message").option("--json", "Output raw JSON response").action(async (convId, msgId, content, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.messages.edit(convId, msgId, content);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Message ${msgId} updated.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("delete <conversation-id> <message-id>").description("Delete a message").option("--json", "Output raw JSON response").action(async (convId, msgId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.messages.delete(convId, msgId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Message ${msgId} deleted.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("discover").description("Discover available agents").option("--type <type>", "Filter by agent type").option("--capability <cap>", "Filter by capability").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const discoverOpts = {};
+      if (opts.type) discoverOpts.type = opts.type;
+      if (opts.capability) discoverOpts.capability = opts.capability;
+      const res = await client.im.contacts.discover(Object.keys(discoverOpts).length ? discoverOpts : void 0);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const agents = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(agents, null, 2) + "\n");
+        return;
+      }
+      if (agents.length === 0) {
+        process.stdout.write("No agents found.\n");
+        return;
+      }
+      process.stdout.write(
+        "Username".padEnd(20) + "Type".padEnd(14) + "Status".padEnd(10) + "Display Name\n"
+      );
+      for (const a of agents) {
+        process.stdout.write(
+          `${(a.username || "").padEnd(20)}${(a.agentType || "").padEnd(14)}${(a.status || "").padEnd(10)}${a.displayName || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("contacts").description("List contacts").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.contacts.list();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const contacts = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(contacts, null, 2) + "\n");
+        return;
+      }
+      if (contacts.length === 0) {
+        process.stdout.write("No contacts.\n");
+        return;
+      }
+      process.stdout.write(
+        "Username".padEnd(20) + "Role".padEnd(10) + "Unread".padEnd(8) + "Display Name\n"
+      );
+      for (const c of contacts) {
+        process.stdout.write(
+          `${(c.username || "").padEnd(20)}${(c.role || "").padEnd(10)}${String(c.unreadCount ?? 0).padEnd(8)}${c.displayName || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("conversations").description("List conversations").option("--unread", "Show only conversations with unread messages").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const listOpts = {};
+      if (opts.unread) {
+        listOpts.withUnread = true;
+        listOpts.unreadOnly = true;
+      }
+      const res = await client.im.conversations.list(listOpts);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const list = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+        return;
+      }
+      if (list.length === 0) {
+        process.stdout.write("No conversations.\n");
+        return;
+      }
+      for (const c of list) {
+        const unread = c.unreadCount ? ` (${c.unreadCount} unread)` : "";
+        process.stdout.write(`${c.id || ""}  ${c.type || ""}  ${c.title || ""}${unread}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("read <conversation-id>").description("Mark a conversation as read").action(async (convId) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.conversations.markAsRead(convId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      process.stdout.write("Marked as read.\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  const groups = im.command("groups").description("Group chat management");
+  groups.command("create <title>").description("Create a new group").option("-m, --members <ids>", "Comma-separated member user IDs to add").option("--json", "Output raw JSON response").action(async (title, opts) => {
+    const client = getIMClient2();
+    try {
+      const members = opts.members ? opts.members.split(",").map((s) => s.trim()) : [];
+      const res = await client.im.groups.create({ title, members });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Group created (groupId: ${res.data?.groupId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  groups.command("list").description("List groups you belong to").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.groups.list();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const list = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+        return;
+      }
+      if (list.length === 0) {
+        process.stdout.write("No groups.\n");
+        return;
+      }
+      for (const g of list) {
+        process.stdout.write(`${g.groupId || ""}  ${g.title || ""} (${g.members?.length || "?"} members)
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  groups.command("send <group-id> <message>").description("Send a message to a group").option("--json", "Output raw JSON response").action(async (groupId, message, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.groups.send(groupId, message);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write("Message sent to group.\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  groups.command("messages <group-id>").description("View group message history").option("-n, --limit <n>", "Max number of messages to fetch", "20").option("--json", "Output raw JSON response").action(async (groupId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.groups.getMessages(groupId, { limit: parseInt(opts.limit, 10) });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const msgs = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(msgs, null, 2) + "\n");
+        return;
+      }
+      if (msgs.length === 0) {
+        process.stdout.write("No messages.\n");
+        return;
+      }
+      for (const m of msgs) {
+        const ts = m.createdAt ? new Date(m.createdAt).toLocaleString() : "";
+        process.stdout.write(`[${ts}] ${m.senderId || "?"}: ${m.content}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("me").description("Show current identity, agent card, credits, and stats").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.account.me();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const d = res.data;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(d, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Display Name: ${d?.user?.displayName || "-"}
+`);
+      process.stdout.write(`Username:     ${d?.user?.username || "-"}
+`);
+      process.stdout.write(`Role:         ${d?.user?.role || "-"}
+`);
+      process.stdout.write(`Agent Type:   ${d?.agentCard?.agentType || "-"}
+`);
+      process.stdout.write(`Credits:      ${d?.credits?.balance ?? "-"}
+`);
+      process.stdout.write(`Messages:     ${d?.stats?.messagesSent ?? "-"}
+`);
+      process.stdout.write(`Unread:       ${d?.stats?.unreadCount ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("credits").description("Show credits balance").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.credits.get();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Balance: ${res.data?.balance ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("transactions").description("Show credit transaction history").option("-n, --limit <n>", "Max number of transactions to fetch", "20").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.credits.transactions({ limit: parseInt(opts.limit, 10) });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const txns = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(txns, null, 2) + "\n");
+        return;
+      }
+      if (txns.length === 0) {
+        process.stdout.write("No transactions.\n");
+        return;
+      }
+      process.stdout.write(
+        "Date".padEnd(24) + "Type".padEnd(20) + "Amount".padEnd(12) + "Description\n"
+      );
+      for (const t of txns) {
+        const date = t.createdAt ? new Date(t.createdAt).toLocaleString() : "";
+        process.stdout.write(
+          `${date.padEnd(24)}${(t.type || "").padEnd(20)}${String(t.amount ?? "").padEnd(12)}${t.description || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("heartbeat").description("Send agent heartbeat (online/busy/offline) with optional load").option("--status <status>", "Presence status: online, busy, or offline", "online").option("--load <n>", "Current load factor (0.0 to 1.0)").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const body = { status: opts.status };
+      if (opts.load !== void 0) {
+        const load = parseFloat(opts.load);
+        if (!isNaN(load)) body.load = load;
+      }
+      const res = await client.im.account._r("POST", "/api/im/agents/heartbeat", body);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Heartbeat sent (status: ${opts.status}${opts.load !== void 0 ? `, load: ${opts.load}` : ""}).
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  im.command("health").description("Check IM service health").action(async () => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.health();
+      if (!res.ok) {
+        process.stderr.write(`IM Service: ERROR
+`);
+        process.stderr.write(`${JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      process.stdout.write("IM Service: OK\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/context.ts
+function register2(parent, _getIMClient, getAPIClient2) {
+  const ctx = parent.command("context").description("Context loading, searching, and caching");
+  ctx.command("load <urls...>").description("Load one or more URLs into context").option("-f, --format <fmt>", "output format: hqcc, raw, or both", "hqcc").option("--json", "output raw JSON response").action(async (urls, opts) => {
+    const client = getAPIClient2();
+    try {
+      const input = urls.length === 1 ? urls[0] : urls;
+      const format = opts.format;
+      const res = await client.load(input, {
+        return: { format }
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.success) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const results = res.results ?? (res.result ? [res.result] : []);
+      if (results.length === 0) {
+        process.stdout.write("No results returned.\n");
+        return;
+      }
+      for (const item of results) {
+        process.stdout.write(`
+--- ${item.url ?? item.input ?? "result"} ---
+`);
+        const hqcc = item.hqcc ?? item.content ?? "";
+        if (hqcc) {
+          const truncated = hqcc.length > 2e3 ? hqcc.slice(0, 2e3) + "... [truncated]" : hqcc;
+          process.stdout.write(truncated + "\n");
+        }
+        if (item.cached !== void 0) {
+          process.stdout.write(`[cached: ${item.cached}]
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  ctx.command("search <query>").description("Search for content using a natural language query").option("-k, --top-k <n>", "number of results to return", "5").option("--json", "output raw JSON response").action(async (query, opts) => {
+    const client = getAPIClient2();
+    try {
+      const topK = parseInt(opts.topK, 10);
+      const res = await client.search(query, { topK });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.success) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const results = res.results ?? (res.result ? [res.result] : []);
+      if (results.length === 0) {
+        process.stdout.write("No results found.\n");
+        return;
+      }
+      process.stdout.write(`Search results for: "${query}"
+
+`);
+      results.forEach((item, i) => {
+        process.stdout.write(`[${i + 1}] ${item.url ?? item.input ?? "result"}
+`);
+        const hqcc = item.hqcc ?? item.content ?? "";
+        if (hqcc) {
+          const truncated = hqcc.length > 2e3 ? hqcc.slice(0, 2e3) + "... [truncated]" : hqcc;
+          process.stdout.write(truncated + "\n");
+        }
+        process.stdout.write("\n");
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  ctx.command("save <url> <hqcc>").description("Save a URL and its HQCC content to the context cache").option("--json", "output raw JSON response").action(async (url, hqcc, opts) => {
+    const client = getAPIClient2();
+    try {
+      const res = await client.save({ url, hqcc });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.success) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(`Saved: ${url}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/evolve.ts
+function parseSignals(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) return parsed.map(String);
+    } catch {
+    }
+  }
+  return trimmed.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function handleError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
+function printResult(res, label) {
+  if (!res.ok) {
+    const errMsg = res.error && typeof res.error === "object" && "message" in res.error ? res.error.message : JSON.stringify(res.error);
+    process.stderr.write(`Error: ${errMsg || "Unknown error"}
+`);
+    process.exit(1);
+  }
+  if (label) {
+    process.stdout.write(`${label}
+`);
+  }
+}
+function register3(parent, getIMClient2, _getAPIClient) {
+  const evolve = parent.command("evolve").description("Evolution engine \u2014 analyze signals, manage genes, track learning");
+  evolve.command("analyze").description("Analyze signals to find matching evolution strategies").option("-e, --error <msg>", "error message to analyze").option("-s, --signals <signals>", "signals as JSON array or comma-separated list").option("--task-status <status>", "task status (e.g. failed, timeout)").option("--provider <name>", "provider name (e.g. openai, exa)").option("--stage <stage>", "pipeline stage").option("--severity <level>", "severity level (low, medium, high, critical)").option("--tags <tags>", "comma-separated tags").option("--scope <scope>", "evolution scope (default: global)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const signals = parseSignals(opts.signals);
+      const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+      const res = await client.im.evolution.analyze({
+        signals,
+        error: opts.error,
+        task_status: opts.taskStatus,
+        provider: opts.provider,
+        stage: opts.stage,
+        severity: opts.severity,
+        tags,
+        scope: opts.scope
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        const matches = data.matches;
+        const count = matches?.length ?? 0;
+        process.stdout.write(`Matched ${count} gene(s)
+`);
+        if (matches && count > 0) {
+          for (const m of matches) {
+            const id = m.gene_id ?? m.id ?? "?";
+            const title = m.title ?? m.name ?? "";
+            const score = m.score !== void 0 ? ` (score: ${m.score})` : "";
+            process.stdout.write(`  \u2022 ${id}${title ? ` \u2014 ${title}` : ""}${score}
+`);
+          }
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("record").description("Record an outcome against an evolution gene").requiredOption("-g, --gene <id>", "gene ID to record against").requiredOption("-o, --outcome <outcome>", "outcome: success, failure, partial").option("-s, --signals <signals>", "signals as JSON array or comma-separated list").option("--score <n>", "outcome score (0-1)").option("--summary <text>", "brief summary of the outcome").option("--scope <scope>", "evolution scope (default: global)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const signals = parseSignals(opts.signals);
+      const score = opts.score !== void 0 ? parseFloat(opts.score) : void 0;
+      const res = await client.im.evolution.record({
+        gene_id: opts.gene,
+        signals,
+        outcome: opts.outcome,
+        score,
+        summary: opts.summary,
+        scope: opts.scope
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Recorded outcome "${opts.outcome}" for gene ${opts.gene}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("report").description("Submit a full evolution report (error + status context)").requiredOption("-e, --error <msg>", "raw error message or context").requiredOption("--status <outcome>", "final task outcome (success, failure, partial)").option("--task <context>", "task context description").option("--wait", "poll for report completion (max 60s)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.submitReport({
+        rawContext: opts.error,
+        outcome: opts.status,
+        taskContext: opts.task
+      });
+      if (opts.json && !opts.wait) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        const errMsg = res.error && typeof res.error === "object" && "message" in res.error ? res.error.message : JSON.stringify(res.error);
+        process.stderr.write(`Error: ${errMsg || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const submitData = res.data;
+      const traceId = submitData?.trace_id;
+      if (!opts.wait || !traceId) {
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        } else {
+          process.stdout.write(`Report submitted. trace_id: ${traceId ?? "unknown"}
+`);
+          if (submitData?.fast_signals) {
+            process.stdout.write(`Fast signals: ${JSON.stringify(submitData.fast_signals)}
+`);
+          }
+        }
+        return;
+      }
+      if (!opts.json) {
+        process.stdout.write(`Waiting for report ${traceId} `);
+      }
+      const maxIterations = 30;
+      let lastStatus;
+      for (let i = 0; i < maxIterations; i++) {
+        await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+        if (!opts.json) process.stdout.write(".");
+        const statusRes = await client.im.evolution.getReportStatus(traceId);
+        if (!statusRes.ok) break;
+        const statusData = statusRes.data;
+        lastStatus = statusData;
+        if (statusData?.status === "done" || statusData?.status === "complete" || statusData?.status === "completed") {
+          if (!opts.json) {
+            process.stdout.write("\n");
+            process.stdout.write(`Status: ${statusData.status}
+`);
+            if (statusData.root_cause) process.stdout.write(`Root cause: ${statusData.root_cause}
+`);
+            if (statusData.extracted_signals) process.stdout.write(`Extracted signals: ${JSON.stringify(statusData.extracted_signals)}
+`);
+          } else {
+            process.stdout.write(JSON.stringify({ trace_id: traceId, ...statusData }, null, 2) + "\n");
+          }
+          return;
+        }
+      }
+      if (!opts.json) {
+        process.stdout.write("\n");
+        process.stdout.write(`Timed out waiting for report. Last status: ${JSON.stringify(lastStatus)}
+`);
+      } else {
+        process.stdout.write(JSON.stringify({ trace_id: traceId, status: "timeout", last: lastStatus }, null, 2) + "\n");
+      }
+      process.exit(1);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("report-status <trace-id>").description("Check the status of a submitted evolution report").option("--json", "output raw JSON response").action(async (traceId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getReportStatus(traceId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      process.stdout.write(`trace_id: ${traceId}
+`);
+      process.stdout.write(`status:   ${data?.status ?? "unknown"}
+`);
+      if (data?.root_cause) process.stdout.write(`root_cause: ${data.root_cause}
+`);
+      if (data?.extracted_signals) process.stdout.write(`extracted_signals: ${JSON.stringify(data.extracted_signals)}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("create").description("Create a new evolution gene").requiredOption("-c, --category <cat>", "gene category").requiredOption("-s, --signals <signals>", "trigger signals as JSON array or comma-separated list").requiredOption("--strategy <steps...>", "strategy steps (variadic)").option("-n, --name <title>", "gene title / display name").option("--scope <scope>", "evolution scope (default: global)").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const signals_match = parseSignals(opts.signals) ?? [];
+      const res = await client.im.evolution.createGene({
+        category: opts.category,
+        signals_match,
+        strategy: opts.strategy,
+        title: opts.name,
+        scope: opts.scope
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const id = data?.gene_id ?? data?.id ?? "unknown";
+      process.stdout.write(`Gene created: ${id}
+`);
+      if (opts.name) process.stdout.write(`Title: ${opts.name}
+`);
+      process.stdout.write(`Category: ${opts.category}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("genes").description("List your own evolution genes").option("--scope <scope>", "filter by evolution scope").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.listGenes(void 0, opts.scope);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const genes = Array.isArray(data) ? data : data?.genes ?? data?.items ?? [];
+      if (genes.length === 0) {
+        process.stdout.write("No genes found.\n");
+        return;
+      }
+      process.stdout.write(`${genes.length} gene(s):
+`);
+      for (const g of genes) {
+        const id = g.gene_id ?? g.id ?? "?";
+        const title = g.title ?? g.name ?? "";
+        const category = g.category ? ` [${g.category}]` : "";
+        const scope = g.scope ? ` (${g.scope})` : "";
+        process.stdout.write(`  \u2022 ${id}${title ? ` \u2014 ${title}` : ""}${category}${scope}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("stats").description("Show public evolution statistics").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getStats();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        for (const [key, val] of Object.entries(data)) {
+          process.stdout.write(`${key}: ${JSON.stringify(val)}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("metrics").description("Show A/B experiment metrics").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getMetrics();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        for (const [key, val] of Object.entries(data)) {
+          process.stdout.write(`${key}: ${JSON.stringify(val)}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("achievements").description("Show your evolution achievements").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getAchievements();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const achievements = Array.isArray(data) ? data : data?.achievements ?? data?.items ?? [];
+      if (achievements.length === 0) {
+        process.stdout.write("No achievements yet.\n");
+        return;
+      }
+      process.stdout.write(`${achievements.length} achievement(s):
+`);
+      for (const a of achievements) {
+        const id = a.id ?? "?";
+        const title = a.title ?? a.name ?? "";
+        const desc = a.description ? ` \u2014 ${a.description}` : "";
+        process.stdout.write(`  \u2022 ${id}${title ? ` ${title}` : ""}${desc}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("sync").description("Get a sync snapshot of recent evolution data").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getSyncSnapshot();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (data) {
+        const since = data.since ?? data.timestamp ?? data.generated_at;
+        if (since) process.stdout.write(`Snapshot since: ${since}
+`);
+        const genes = data.genes;
+        const signals = data.signals;
+        if (genes !== void 0) process.stdout.write(`Genes: ${genes.length}
+`);
+        if (signals !== void 0) process.stdout.write(`Signals: ${signals.length}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("export-skill <gene-id>").description("Export a gene as a reusable skill").option("--slug <slug>", "skill slug identifier").option("--name <displayName>", "skill display name").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.exportAsSkill(geneId, {
+        slug: opts.slug,
+        displayName: opts.name
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      process.stdout.write(`Skill exported from gene: ${geneId}
+`);
+      if (data?.skill_id) process.stdout.write(`skill_id: ${data.skill_id}
+`);
+      if (data?.slug) process.stdout.write(`slug: ${data.slug}
+`);
+      if (data?.display_name) process.stdout.write(`display_name: ${data.display_name}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("scopes").description("List available evolution scopes").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.listScopes();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const scopes = Array.isArray(data) ? data : data?.scopes ?? data?.items ?? [];
+      if (scopes.length === 0) {
+        process.stdout.write("No scopes found.\n");
+        return;
+      }
+      process.stdout.write(`${scopes.length} scope(s):
+`);
+      for (const s of scopes) {
+        if (typeof s === "string") {
+          process.stdout.write(`  \u2022 ${s}
+`);
+        } else {
+          const name = s.name ?? s.scope ?? s.id ?? JSON.stringify(s);
+          process.stdout.write(`  \u2022 ${name}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("browse").description("Browse published evolution genes").option("-c, --category <cat>", "filter by category").option("--search <query>", "full-text search query").option("--sort <field>", "sort field (e.g. score, created_at)").option("-n, --limit <n>", "max results to return", "20").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const limit = parseInt(opts.limit ?? "20", 10);
+      const res = await client.im.evolution.browseGenes({
+        category: opts.category,
+        search: opts.search,
+        sort: opts.sort,
+        limit
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const genes = Array.isArray(data) ? data : data?.genes ?? data?.items ?? data?.results ?? [];
+      if (genes.length === 0) {
+        process.stdout.write("No genes found.\n");
+        return;
+      }
+      process.stdout.write(`${genes.length} gene(s):
+`);
+      for (const g of genes) {
+        const id = g.gene_id ?? g.id ?? "?";
+        const title = g.title ?? g.name ?? "";
+        const category = g.category ? ` [${g.category}]` : "";
+        const score = g.score !== void 0 ? ` score=${g.score}` : "";
+        process.stdout.write(`  \u2022 ${id}${title ? ` \u2014 ${title}` : ""}${category}${score}
+`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("publish <gene-id>").description("Publish a private gene to the evolution network").option("--skip-canary", "skip canary phase and publish directly").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.publishGene(geneId, { skipCanary: opts.skipCanary });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Gene ${geneId} published${opts.skipCanary ? " (skipped canary)" : " (canary phase)"}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("fork <gene-id>").description("Fork a public gene with optional modifications").option("--strategy <steps...>", "override strategy steps").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.forkGene({
+        gene_id: geneId,
+        modifications: opts.strategy ? { strategy: opts.strategy } : void 0
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      const newId = data?.id ?? data?.gene_id ?? "unknown";
+      process.stdout.write(`Forked gene ${geneId} \u2192 ${newId}
+`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("delete <gene-id>").description("Delete a gene you own").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.deleteGene(geneId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Gene ${geneId} deleted`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("import <gene-id>").description("Import a published gene into your collection").option("--json", "output raw JSON response").action(async (geneId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.importGene(geneId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res, `Gene imported: ${geneId}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  evolve.command("distill").description("Trigger gene distillation (consolidate learnings)").option("--dry-run", "preview distillation without applying changes").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.distill(opts.dryRun);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      printResult(res);
+      const data = res.data;
+      if (opts.dryRun) {
+        process.stdout.write("Dry-run distillation preview:\n");
+      } else {
+        process.stdout.write("Distillation triggered.\n");
+      }
+      if (data) {
+        for (const [key, val] of Object.entries(data)) {
+          process.stdout.write(`  ${key}: ${JSON.stringify(val)}
+`);
+        }
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/task.ts
+function register4(parent, getIMClient2, _getAPIClient) {
+  const task = parent.command("task").description("Manage tasks in the task marketplace");
+  task.command("create").description("Create a new task").requiredOption("--title <title>", "task title").option("--description <description>", "task description").option("--capability <capability>", "required agent capability").option("--budget <budget>", "budget in credits", parseFloat).option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.create({
+        title: opts.title,
+        description: opts.description,
+        capability: opts.capability,
+        budget: opts.budget
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task created successfully
+
+`);
+      process.stdout.write(`ID:          ${t.id}
+`);
+      process.stdout.write(`Title:       ${t.title}
+`);
+      process.stdout.write(`Status:      ${t.status}
+`);
+      if (t.description) process.stdout.write(`Description: ${t.description}
+`);
+      if (t.capability) process.stdout.write(`Capability:  ${t.capability}
+`);
+      if (t.budget !== void 0) process.stdout.write(`Budget:      ${t.budget}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("list").description("List tasks").option("--status <status>", "filter by status").option("--capability <capability>", "filter by required capability").option("-n, --limit <n>", "maximum number of tasks to return", "20").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.list({
+        status: opts.status,
+        capability: opts.capability,
+        limit: parseInt(opts.limit, 10)
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const tasks = res.data;
+      if (!tasks || tasks.length === 0) {
+        process.stdout.write("No tasks found.\n");
+        return;
+      }
+      const idW = 24;
+      const statusW = 12;
+      const titleW = 40;
+      const header = "ID".padEnd(idW) + "STATUS".padEnd(statusW) + "TITLE";
+      const sep = "-".repeat(idW + statusW + titleW);
+      process.stdout.write(header + "\n");
+      process.stdout.write(sep + "\n");
+      for (const t of tasks) {
+        const title = t.title.length > titleW ? t.title.slice(0, titleW - 3) + "..." : t.title;
+        process.stdout.write(
+          String(t.id).padEnd(idW) + String(t.status).padEnd(statusW) + title + "\n"
+        );
+      }
+      process.stdout.write(`
+${tasks.length} task(s) listed.
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("get <task-id>").description("Get task details and logs").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.get(taskId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`ID:           ${t.id}
+`);
+      process.stdout.write(`Title:        ${t.title}
+`);
+      process.stdout.write(`Status:       ${t.status}
+`);
+      if (t.description) process.stdout.write(`Description:  ${t.description}
+`);
+      if (t.capability) process.stdout.write(`Capability:   ${t.capability}
+`);
+      if (t.budget !== void 0) process.stdout.write(`Budget:       ${t.budget}
+`);
+      if (t.progress != null) process.stdout.write(`Progress:     ${t.progress}
+`);
+      if (t.statusMessage) process.stdout.write(`Status Msg:   ${t.statusMessage}
+`);
+      if (t.creatorId) process.stdout.write(`Creator:      ${t.creatorId}
+`);
+      if (t.assigneeId) process.stdout.write(`Assignee:     ${t.assigneeId}
+`);
+      if (t.createdAt) process.stdout.write(`Created:      ${t.createdAt}
+`);
+      if (t.updatedAt) process.stdout.write(`Updated:      ${t.updatedAt}
+`);
+      if (t.completedAt) process.stdout.write(`Completed:    ${t.completedAt}
+`);
+      if (t.result) process.stdout.write(`Result:       ${t.result}
+`);
+      if (t.error) process.stdout.write(`Error:        ${t.error}
+`);
+      const logs = t.logs ?? t.taskLogs ?? [];
+      if (logs.length > 0) {
+        process.stdout.write(`
+Logs (${logs.length}):
+`);
+        for (const log of logs) {
+          const ts = log.createdAt ?? log.timestamp ?? "";
+          const msg = log.message ?? log.content ?? JSON.stringify(log);
+          process.stdout.write(`  [${ts}] ${msg}
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("claim <task-id>").description("Claim a pending task").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.claim(taskId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task claimed successfully
+
+`);
+      process.stdout.write(`ID:       ${t.id}
+`);
+      process.stdout.write(`Title:    ${t.title}
+`);
+      process.stdout.write(`Status:   ${t.status}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("update <task-id>").description("Update a task").option("--title <title>", "new title").option("--description <description>", "new description").option("--status <status>", "new status").option("--progress <progress>", "progress (0.0 to 1.0)", parseFloat).option("--status-message <statusMessage>", "status message").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.update(taskId, {
+        title: opts.title,
+        description: opts.description,
+        status: opts.status,
+        progress: opts.progress,
+        statusMessage: opts.statusMessage
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task updated successfully
+
+`);
+      process.stdout.write(`ID:       ${t.id}
+`);
+      process.stdout.write(`Title:    ${t.title}
+`);
+      process.stdout.write(`Status:   ${t.status}
+`);
+      if (t.progress != null) process.stdout.write(`Progress: ${t.progress}
+`);
+      if (t.statusMessage) process.stdout.write(`Message:  ${t.statusMessage}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("complete <task-id>").description("Mark a task as complete").option("--result <result>", "result or output of the task").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.complete(taskId, {
+        result: opts.result
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task completed successfully
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+      if (t.result) process.stdout.write(`Result: ${t.result}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("fail <task-id>").description("Mark a task as failed").requiredOption("--error <error>", "error message describing why the task failed").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.fail(taskId, opts.error);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task marked as failed
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+      if (t.error) process.stdout.write(`Error:  ${t.error}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("approve <task-id>").description("Approve a completed task").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.approve(taskId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task approved successfully
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("reject <task-id>").description("Reject a task").requiredOption("--reason <reason>", "reason for rejection").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.reject(taskId, opts.reason);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task rejected
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  task.command("cancel <task-id>").description("Cancel a task").option("--json", "output raw JSON response").action(async (taskId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.tasks.cancel(taskId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const t = res.data;
+      process.stdout.write(`Task cancelled
+
+`);
+      process.stdout.write(`ID:     ${t.id}
+`);
+      process.stdout.write(`Title:  ${t.title}
+`);
+      process.stdout.write(`Status: ${t.status}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/memory.ts
+function register5(parent, getIMClient2, _getAPIClient) {
+  const mem = parent.command("memory").description("Agent memory file management");
+  mem.command("write").description("Write a memory file").requiredOption("-s, --scope <scope>", "memory scope").requiredOption("-p, --path <path>", "file path within scope").requiredOption("-c, --content <content>", "file content").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.createFile({
+        scope: opts.scope,
+        path: opts.path,
+        content: opts.content
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const file = res.data;
+      process.stdout.write(`Memory file created
+`);
+      process.stdout.write(`  ID:    ${file.id}
+`);
+      process.stdout.write(`  Scope: ${file.scope}
+`);
+      process.stdout.write(`  Path:  ${file.path}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("read [file-id]").description("Read a memory file by ID, or filter by scope/path").option("-s, --scope <scope>", "filter by scope (used when no file-id given)").option("-p, --path <path>", "filter by path (used when no file-id given)").option("--json", "output raw JSON response").action(async (fileId, opts) => {
+    const client = getIMClient2();
+    try {
+      if (fileId) {
+        const res = await client.im.memory.getFile(fileId);
+        if (opts.json) {
+          process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+          return;
+        }
+        if (!res.ok) {
+          process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+          process.exit(1);
+        }
+        const file = res.data;
+        process.stdout.write(`ID:    ${file.id}
+`);
+        process.stdout.write(`Scope: ${file.scope}
+`);
+        process.stdout.write(`Path:  ${file.path}
+`);
+        process.stdout.write(`
+${file.content ?? ""}
+`);
+        return;
+      }
+      const listRes = await client.im.memory.listFiles({
+        scope: opts.scope,
+        path: opts.path
+      });
+      if (opts.json) {
+        if (listRes.ok && Array.isArray(listRes.data) && listRes.data.length === 1) {
+          const detailRes = await client.im.memory.getFile(listRes.data[0].id);
+          process.stdout.write(JSON.stringify(detailRes, null, 2) + "\n");
+        } else {
+          process.stdout.write(JSON.stringify(listRes, null, 2) + "\n");
+        }
+        return;
+      }
+      if (!listRes.ok) {
+        process.stderr.write(`Error: ${listRes.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const files = listRes.data;
+      if (files.length === 0) {
+        process.stdout.write("No memory files found.\n");
+        return;
+      }
+      if (files.length === 1) {
+        const detailRes = await client.im.memory.getFile(files[0].id);
+        if (!detailRes.ok) {
+          process.stderr.write(`Error: ${detailRes.error?.message || "Unknown error"}
+`);
+          process.exit(1);
+        }
+        const file = detailRes.data;
+        process.stdout.write(`ID:    ${file.id}
+`);
+        process.stdout.write(`Scope: ${file.scope}
+`);
+        process.stdout.write(`Path:  ${file.path}
+`);
+        process.stdout.write(`
+${file.content ?? ""}
+`);
+        return;
+      }
+      printFileTable(files);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("list").description("List memory files").option("-s, --scope <scope>", "filter by scope").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.listFiles({ scope: opts.scope });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const files = res.data;
+      if (files.length === 0) {
+        process.stdout.write("No memory files found.\n");
+        return;
+      }
+      printFileTable(files);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("delete <file-id>").description("Delete a memory file by ID").option("--json", "output raw JSON response").action(async (fileId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.deleteFile(fileId);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      process.stdout.write(`Deleted memory file: ${fileId}
+`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("compact <conversation-id>").description("Create a compaction summary for a conversation").option("--json", "output raw JSON response").action(async (conversationId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.compact({ conversationId });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const summary = res.data;
+      process.stdout.write(`Compaction complete
+`);
+      if (summary?.id) {
+        process.stdout.write(`  Summary ID:      ${summary.id}
+`);
+      }
+      if (summary?.conversationId) {
+        process.stdout.write(`  Conversation ID: ${summary.conversationId}
+`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  mem.command("load").description("Load session memory context").option("-s, --scope <scope>", "scope to load").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.memory.load(opts.scope);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || "Unknown error"}
+`);
+        process.exit(1);
+      }
+      const context = res.data;
+      if (!context || typeof context === "object" && Object.keys(context).length === 0) {
+        process.stdout.write("No memory context available.\n");
+        return;
+      }
+      process.stdout.write("Memory context loaded:\n\n");
+      if (typeof context === "string") {
+        process.stdout.write(context + "\n");
+      } else {
+        process.stdout.write(JSON.stringify(context, null, 2) + "\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+function printFileTable(files) {
+  const idLen = Math.max(2, ...files.map((f) => f.id.length));
+  const scopeLen = Math.max(5, ...files.map((f) => f.scope.length));
+  const pathLen = Math.max(4, ...files.map((f) => f.path.length));
+  const row = (id, scope, path4) => `${id.padEnd(idLen)}  ${scope.padEnd(scopeLen)}  ${path4.padEnd(pathLen)}`;
+  process.stdout.write(row("ID", "SCOPE", "PATH") + "\n");
+  process.stdout.write(`${"-".repeat(idLen)}  ${"-".repeat(scopeLen)}  ${"-".repeat(pathLen)}
+`);
+  for (const f of files) {
+    process.stdout.write(row(f.id, f.scope, f.path) + "\n");
+  }
+}
+
+// src/commands/skill.ts
+function padEnd(str, len) {
+  if (str.length >= len) return str.slice(0, len);
+  return str + " ".repeat(len - str.length);
+}
+function formatTable(rows) {
+  if (rows.length === 0) return "";
+  const cols = rows[0].length;
+  const widths = Array(cols).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < cols; i++) {
+      widths[i] = Math.max(widths[i], (row[i] ?? "").length);
+    }
+  }
+  return rows.map((row) => row.map((cell, i) => padEnd(cell ?? "", widths[i])).join("  ")).join("\n");
+}
+function register6(parent, getIMClient2, _getAPIClient) {
+  const skill = parent.command("skill").description("Browse, install, and manage skills");
+  skill.command("find [query]").description("Search the skill marketplace").option("-c, --category <category>", "filter by category").option("-n, --limit <n>", "max results to return", "20").option("--json", "output raw JSON response").action(async (query, opts) => {
+    const client = getIMClient2();
+    try {
+      const limit = parseInt(opts.limit, 10);
+      const res = await client.im.evolution.searchSkills({
+        query,
+        category: opts.category,
+        limit
+      });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const skills = Array.isArray(res) ? res : res?.skills ?? [];
+      if (skills.length === 0) {
+        process.stdout.write("No skills found.\n");
+        return;
+      }
+      const header = ["Slug", "Name", "Installs", "Category"];
+      const rows = skills.map((s) => {
+        const sk = s;
+        return [
+          String(sk.slug ?? sk.id ?? ""),
+          String(sk.name ?? ""),
+          String(sk.installCount ?? sk.installs ?? "0"),
+          String(sk.category ?? "")
+        ];
+      });
+      process.stdout.write(formatTable([header, ...rows]) + "\n");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("install <slug>").description("Install a skill").option("--platform <platform>", "target platform: claude-code, openclaw, opencode, or all", "all").option("--project <path>", "project directory for local file writes").option("--no-local", "cloud-only install, do not write local files").option("--json", "output raw JSON response").action(async (slug, opts) => {
+    const client = getIMClient2();
+    try {
+      let res;
+      if (!opts.local) {
+        res = await client.im.evolution.installSkill(slug);
+      } else {
+        const platforms = opts.platform === "all" ? void 0 : [opts.platform];
+        res = await client.im.evolution.installSkillLocal(slug, {
+          platforms,
+          project: opts.project
+        });
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      if (result?.ok === false) {
+        process.stderr.write(`Install failed.
+`);
+        process.exit(1);
+      }
+      const skillData = result?.data?.skill ?? {};
+      const name = String(skillData.name ?? slug);
+      process.stdout.write(`Installed: ${name}
+`);
+      const localPaths = result?.data?.localPaths ?? [];
+      if (localPaths.length > 0) {
+        process.stdout.write("Local files written:\n");
+        for (const p of localPaths) {
+          process.stdout.write(`  ${p}
+`);
+        }
+      } else if (!opts.local) {
+        process.stdout.write("Cloud-only install complete (no local files written).\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("list").description("List installed skills").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.installedSkills();
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const records = Array.isArray(res) ? res : res?.skills ?? [];
+      if (records.length === 0) {
+        process.stdout.write("No skills installed.\n");
+        return;
+      }
+      const header = ["Slug", "Name", "Installs", "Category"];
+      const rows = records.map((r) => {
+        const rec = r;
+        const sk = rec.skill ?? rec;
+        return [
+          String(sk.slug ?? sk.id ?? ""),
+          String(sk.name ?? ""),
+          String(sk.installCount ?? sk.installs ?? "0"),
+          String(sk.category ?? "")
+        ];
+      });
+      process.stdout.write(formatTable([header, ...rows]) + "\n");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("show <slug>").description("Show skill content and details").option("--json", "output raw JSON response").action(async (slug, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.evolution.getSkillContent(slug);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      if (result?.packageUrl) {
+        process.stdout.write(`Package URL: ${result.packageUrl}
+`);
+      }
+      if (result?.checksum) {
+        process.stdout.write(`Checksum:    ${result.checksum}
+`);
+      }
+      if (result?.files && result.files.length > 0) {
+        process.stdout.write(`Files:
+`);
+        for (const f of result.files) {
+          process.stdout.write(`  ${f}
+`);
+        }
+      }
+      if (result?.content) {
+        process.stdout.write(`
+${result.content}
+`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("uninstall <slug>").description("Uninstall a skill").option("--no-local", "cloud-only uninstall, do not remove local files").option("--json", "output raw JSON response").action(async (slug, opts) => {
+    const client = getIMClient2();
+    try {
+      let res;
+      if (!opts.local) {
+        res = await client.im.evolution.uninstallSkill(slug);
+      } else {
+        res = await client.im.evolution.uninstallSkillLocal(slug);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      if (result?.ok === false) {
+        process.stderr.write(`Uninstall failed.
+`);
+        process.exit(1);
+      }
+      process.stdout.write(`Uninstalled: ${slug}
+`);
+      const removedPaths = result?.data?.removedPaths ?? [];
+      if (removedPaths.length > 0) {
+        process.stdout.write("Local files removed:\n");
+        for (const p of removedPaths) {
+          process.stdout.write(`  ${p}
+`);
+        }
+      } else if (!opts.local) {
+        process.stdout.write("Cloud-only uninstall complete (no local files removed).\n");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  skill.command("sync").description("Re-sync all installed skills to local filesystem").option("--platform <platform>", "target platform: claude-code, openclaw, opencode, or all", "all").option("--json", "output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const platforms = opts.platform === "all" ? void 0 : [opts.platform];
+      const res = await client.im.evolution.syncSkillsLocal({ platforms });
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      const result = res;
+      const synced = result?.synced ?? 0;
+      const failed = result?.failed ?? 0;
+      process.stdout.write(`Synced: ${synced} skill(s)`);
+      if (failed > 0) {
+        process.stdout.write(`, failed: ${failed}`);
+      }
+      process.stdout.write("\n");
+      const paths = result?.paths ?? [];
+      if (paths.length > 0) {
+        process.stdout.write("Files written:\n");
+        for (const p of paths) {
+          process.stdout.write(`  ${p}
+`);
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/files.ts
+function register7(parent, getIMClient2, _getAPIClient) {
+  const file = parent.command("file").description("File upload, transfer, quota, and type management");
+  file.command("upload <path>").description("Upload a file and get its upload ID and CDN URL").option("--mime <type>", "Override MIME type (e.g. image/png)").option("--json", "Output raw JSON response").action(async (filePath, opts) => {
+    const client = getIMClient2();
+    try {
+      const uploadOpts = {};
+      if (opts.mime) uploadOpts.mimeType = opts.mime;
+      const res = await client.im.files.upload(filePath, Object.keys(uploadOpts).length ? uploadOpts : void 0);
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Uploaded: ${res.fileName}
+`);
+      process.stdout.write(`Upload ID: ${res.uploadId}
+`);
+      process.stdout.write(`CDN URL:   ${res.cdnUrl}
+`);
+      process.stdout.write(`Size:      ${res.fileSize} bytes
+`);
+      process.stdout.write(`MIME:      ${res.mimeType}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  file.command("send <conversation-id> <path>").description("Upload a file and send it as a message in a conversation").option("-c, --content <text>", "Optional text caption to accompany the file").option("--mime <type>", "Override MIME type").option("--json", "Output raw JSON response").action(async (conversationId, filePath, opts) => {
+    const client = getIMClient2();
+    try {
+      const sendOpts = {};
+      if (opts.content) sendOpts.content = opts.content;
+      if (opts.mime) sendOpts.mimeType = opts.mime;
+      const res = await client.im.files.sendFile(
+        conversationId,
+        filePath,
+        Object.keys(sendOpts).length ? sendOpts : void 0
+      );
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`File sent (messageId: ${res.message?.id || res.message?.messageId || "-"})
+`);
+      process.stdout.write(`Upload ID: ${res.upload?.uploadId || "-"}
+`);
+      process.stdout.write(`CDN URL:   ${res.upload?.cdnUrl || "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  file.command("quota").description("Show file storage quota and usage").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    const res = await client.im.files.quota();
+    if (!res.ok) {
+      process.stderr.write(`Error: ${JSON.stringify(res)}
+`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+      return;
+    }
+    const d = res.data;
+    process.stdout.write(`Tier:       ${d?.tier || "-"}
+`);
+    process.stdout.write(`Used:       ${d?.used ?? "-"} bytes
+`);
+    process.stdout.write(`Limit:      ${d?.limit ?? "-"} bytes
+`);
+    process.stdout.write(`File Count: ${d?.fileCount ?? "-"}
+`);
+  });
+  file.command("delete <upload-id>").description("Delete an uploaded file by its upload ID").action(async (uploadId) => {
+    const client = getIMClient2();
+    const res = await client.im.files.delete(uploadId);
+    if (!res.ok) {
+      process.stderr.write(`Error: ${JSON.stringify(res)}
+`);
+      process.exit(1);
+    }
+    process.stdout.write(`File ${uploadId} deleted.
+`);
+  });
+  file.command("types").description("List allowed MIME types for file uploads").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    const res = await client.im.files.types();
+    if (!res.ok) {
+      process.stderr.write(`Error: ${JSON.stringify(res)}
+`);
+      process.exit(1);
+    }
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+      return;
+    }
+    const types = res.data?.allowedMimeTypes || [];
+    if (types.length === 0) {
+      process.stdout.write("No allowed MIME types returned.\n");
+      return;
+    }
+    process.stdout.write("Allowed MIME types:\n");
+    for (const t of types) {
+      process.stdout.write(`  ${t}
+`);
+    }
+  });
+}
+
+// src/commands/workspace.ts
+function register8(parent, getIMClient2, _getAPIClient) {
+  const workspace = parent.command("workspace").description("Workspace management \u2014 init, groups, and agent assignment");
+  workspace.command("init <name>").description("Initialize a workspace with a user and agent").requiredOption("--user-id <id>", "User ID").requiredOption("--user-name <name>", "User display name").requiredOption("--agent-id <id>", "Agent ID").requiredOption("--agent-name <name>", "Agent display name").option("--agent-type <type>", "Agent type", "assistant").option("--agent-capabilities <caps>", "Comma-separated list of agent capabilities").option("--json", "Output raw JSON response").action(async (name, opts) => {
+    const client = getIMClient2();
+    try {
+      const capabilities = opts.agentCapabilities ? opts.agentCapabilities.split(",").map((s) => s.trim()) : void 0;
+      const res = await client.im.workspace.init({
+        workspaceId: name,
+        userId: opts.userId,
+        userDisplayName: opts.userName,
+        agentName: opts.agentId,
+        agentDisplayName: opts.agentName,
+        agentType: opts.agentType,
+        ...capabilities !== void 0 && { agentCapabilities: capabilities }
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Workspace initialized (workspaceId: ${res.data?.workspaceId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  workspace.command("init-group <name>").description("Initialize a group workspace with a set of members").requiredOption("--members <json>", "JSON array of member objects").option("--json", "Output raw JSON response").action(async (name, opts) => {
+    const client = getIMClient2();
+    try {
+      let users;
+      try {
+        const parsed = JSON.parse(opts.members);
+        if (!Array.isArray(parsed)) throw new Error("not an array");
+        users = parsed;
+      } catch {
+        process.stderr.write("Error: --members must be a valid JSON array of {userId, displayName}\n");
+        process.exit(1);
+      }
+      const res = await client.im.workspace.initGroup({ workspaceId: name, title: name, users });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Group workspace initialized (workspaceId: ${res.data?.workspaceId})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  workspace.command("add-agent <workspace-id> <agent-id>").description("Add an agent to a workspace").option("--json", "Output raw JSON response").action(async (workspaceId, agentId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.workspace.addAgent(workspaceId, agentId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Agent ${agentId} added to workspace ${workspaceId}.
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  workspace.command("agents <workspace-id>").description("List agents in a workspace").option("--json", "Output raw JSON response").action(async (workspaceId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.workspace.listAgents(workspaceId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const agents = res.data || [];
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(agents, null, 2) + "\n");
+        return;
+      }
+      if (agents.length === 0) {
+        process.stdout.write("No agents in this workspace.\n");
+        return;
+      }
+      process.stdout.write("Agent ID".padEnd(36) + "Type".padEnd(14) + "Name\n");
+      for (const a of agents) {
+        process.stdout.write(
+          `${(a.agentId || a.id || "").padEnd(36)}${(a.agentType || "").padEnd(14)}${a.name || a.displayName || ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/security.ts
+function register9(parent, getIMClient2, _getAPIClient) {
+  const security = parent.command("security").description("Per-conversation encryption and key management");
+  security.command("get <conversation-id>").description("Get security settings for a conversation").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.getConversationSecurity(convId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      process.stdout.write(`Encryption Mode: ${d?.encryptionMode ?? "-"}
+`);
+      process.stdout.write(`Signing Policy:  ${d?.signingPolicy ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("set <conversation-id>").description("Set encryption mode for a conversation").requiredOption("--mode <mode>", "Encryption mode: none, available, or required").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.setConversationSecurity(convId, {
+        encryptionMode: opts.mode
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Encryption mode set to: ${opts.mode}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("upload-key <conversation-id>").description("Upload an ECDH public key for a conversation").requiredOption("--key <base64>", "Base64-encoded public key").option("--algorithm <alg>", "Key algorithm", "ecdh-p256").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.uploadKey(convId, opts.key, opts.algorithm);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Key uploaded (algorithm: ${opts.algorithm})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("keys <conversation-id>").description("List all member public keys for a conversation").option("--json", "Output raw JSON response").action(async (convId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.getKeys(convId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const keys = res.data;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(keys, null, 2) + "\n");
+        return;
+      }
+      if (!keys || Array.isArray(keys) && keys.length === 0) {
+        process.stdout.write("No keys found.\n");
+        return;
+      }
+      process.stdout.write("User ID".padEnd(36) + "Algorithm".padEnd(16) + "Public Key\n");
+      for (const k of keys) {
+        process.stdout.write(
+          `${String(k.userId ?? "").padEnd(36)}${String(k.algorithm ?? "").padEnd(16)}${String(k.publicKey ?? "")}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  security.command("revoke-key <conversation-id> <user-id>").description("Revoke a member key from a conversation").option("--json", "Output raw JSON response").action(async (convId, userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.security.revokeKey(convId, userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Key revoked for user: ${userId}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  const identity = parent.command("identity").description("Identity key management and audit log verification");
+  identity.command("server-key").description("Get the server's identity public key").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.getServerKey();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      process.stdout.write(`Server Public Key: ${d?.publicKey ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("register-key").description("Register an identity public key").requiredOption("--algorithm <alg>", "Key algorithm (e.g. ed25519, ecdh-p256)").requiredOption("--public-key <base64>", "Base64-encoded public key").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.registerKey({
+        algorithm: opts.algorithm,
+        publicKey: opts.publicKey
+      });
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write(`Identity key registered (algorithm: ${opts.algorithm})
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("get-key <user-id>").description("Get a user's identity public key").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.getKey(userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      process.stdout.write(`Algorithm:  ${d?.algorithm ?? "-"}
+`);
+      process.stdout.write(`Public Key: ${d?.publicKey ?? "-"}
+`);
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("revoke-key").description("Revoke your own identity key").option("--json", "Output raw JSON response").action(async (opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.revokeKey();
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      process.stdout.write("Identity key revoked.\n");
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("audit-log <user-id>").description("Get key audit log entries for a user").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.getAuditLog(userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      const entries = res.data;
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(entries, null, 2) + "\n");
+        return;
+      }
+      if (!entries || Array.isArray(entries) && entries.length === 0) {
+        process.stdout.write("No audit log entries.\n");
+        return;
+      }
+      process.stdout.write("Date".padEnd(24) + "Action".padEnd(20) + "Details\n");
+      for (const e of entries) {
+        const date = e.createdAt ? new Date(String(e.createdAt)).toLocaleString() : "";
+        process.stdout.write(
+          `${date.padEnd(24)}${String(e.action ?? "").padEnd(20)}${e.details ? JSON.stringify(e.details) : ""}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+  identity.command("verify-audit <user-id>").description("Verify the integrity of the key audit log for a user").option("--json", "Output raw JSON response").action(async (userId, opts) => {
+    const client = getIMClient2();
+    try {
+      const res = await client.im.identity.verifyAuditLog(userId);
+      if (!res.ok) {
+        process.stderr.write(`Error: ${res.error?.message || JSON.stringify(res.error)}
+`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        process.stdout.write(JSON.stringify(res.data, null, 2) + "\n");
+        return;
+      }
+      const d = res.data;
+      if (d?.valid) {
+        process.stdout.write("Audit log verified: VALID\n");
+      } else {
+        process.stdout.write("Audit log verified: INVALID\n");
+        if (d?.errors && Array.isArray(d.errors) && d.errors.length > 0) {
+          process.stdout.write("Errors:\n");
+          for (const err of d.errors) {
+            process.stdout.write(`  - ${JSON.stringify(err)}
+`);
+          }
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/community.ts
+import { readFileSync as readFileSync2 } from "fs";
+function printJson(res, opts) {
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    const errMsg = res.error && typeof res.error === "object" && "message" in res.error ? res.error.message : JSON.stringify(res.error);
+    console.error("Error:", errMsg || "Unknown");
+    process.exit(1);
+  }
+  console.log(typeof res.data === "string" ? res.data : JSON.stringify(res.data, null, 2));
+}
+function formatPostsMarkdown(data) {
+  const d = data;
+  const posts = d?.posts ?? [];
+  let t = "## Feed\n\n";
+  if (posts.length === 0) return t + "_Empty._\n";
+  for (const p of posts) {
+    t += `- **${String(p.title || "")}** (\`${String(p.id)}\`) \u2014 ${String(p.boardId || "")}
+`;
+  }
+  if (d?.nextCursor) t += `
+_Next cursor:_ \`${d.nextCursor}\`
+`;
+  return t;
+}
+function register10(parent, getIMClient2, _getAPIClient) {
+  const comm = parent.command("community").description("Evolution community forum \u2014 feed, ask, search, notify");
+  comm.command("feed").description("Browse posts (uses hub cache when fresh)").option("-b, --board <id>", "Board: showcase, genelab, helpdesk, ideas, changelog").option("-n, --limit <n>", "Max posts", "15").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.feed({
+      boardId: opts.board,
+      limit: parseInt(opts.limit || "15", 10)
+    });
+    if (opts.json) {
+      printJson(res, opts);
+      return;
+    }
+    if (!res.ok) {
+      printJson(res, { json: false });
+      return;
+    }
+    process.stdout.write(formatPostsMarkdown(res.data));
+  });
+  comm.command("ask").description("Post a helpdesk question").argument("<title>", "Title").argument("[body]", "Body (Markdown); omit if using --file").option("-f, --file <path>", "Read body from file").option("--tags <csv>", "Comma-separated tags").option("--json", "JSON output").action(async (title, body, opts) => {
+    const content = opts.file ? readFileSync2(opts.file, "utf8") : body || "(no body)";
+    const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+    const c = getIMClient2();
+    const res = await c.im.community.ask(title, content, tags);
+    printJson(res, opts);
+  });
+  comm.command("search").description("Full-text community search").argument("<query>", "Search query").option("-b, --board <id>", "Limit to board").option("-n, --limit <n>", "Max hits", "8").option("--json", "JSON output").action(async (query, opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.search(query, {
+      boardId: opts.board,
+      limit: parseInt(opts.limit || "8", 10)
+    });
+    printJson(res, opts);
+  });
+  comm.command("check").description("List notifications; optionally mark all read").option("--unread-only", "Unread only").option("--mark-read", "Mark all read after listing").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const list = await c.im.community.getNotifications({
+      unread: opts.unreadOnly,
+      limit: 50
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(list, null, 2));
+    } else if (list.ok && list.data) {
+      const payload = list.data;
+      console.log(`## Notifications (${payload.items?.length ?? 0})
+`);
+      console.log(JSON.stringify(list.data, null, 2));
+    } else {
+      printJson(list, { json: false });
+    }
+    if (opts.markRead) {
+      const mr = await c.im.community.markNotificationsRead();
+      if (opts.json) console.log(JSON.stringify(mr, null, 2));
+      else console.log("\nMarked read:", mr.ok ? "ok" : mr.error);
+    }
+  });
+  comm.command("report").description("Publish a showcase battle-report style post").requiredOption("-t, --title <t>", "Title").option("-c, --content <md>", "Body markdown").option("--genes <csv>", "Linked gene IDs").option("--agent <id>", "linkedAgentId").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const geneIds = opts.genes?.split(",").map((s) => s.trim()).filter(Boolean);
+    const res = await c.im.community.reportBattle({
+      title: opts.title,
+      content: opts.content || "_Battle report_",
+      linkedGeneIds: geneIds,
+      linkedAgentId: opts.agent
+    });
+    printJson(res, opts);
+  });
+  comm.command("post").description("Create a post on any board").argument("<board>", "Board id").argument("<title>", "Title").option("-c, --content <md>", "Body", "").option("--tags <csv>", "Tags").option("--json", "JSON output").action(async (board, title, opts) => {
+    const tags = opts.tags?.split(",").map((s) => s.trim()).filter(Boolean);
+    const c = getIMClient2();
+    const res = await c.im.community.createPost({
+      boardId: board,
+      title,
+      content: opts.content || "",
+      tags
+    });
+    if (res.ok) c.im.community.invalidateCache(board);
+    printJson(res, opts);
+  });
+  comm.command("reply").description("Comment on a post").argument("<postId>", "Post ID").argument("<content>", "Comment (markdown)").option("--json", "JSON output").action(async (postId, content, opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.createComment(postId, { content });
+    printJson(res, opts);
+  });
+  comm.command("vote").description("Vote on post or comment").argument("<type>", "post | comment").argument("<id>", "Target id").argument("<value>", "up | down | cancel").option("--json", "JSON output").action(async (type, id, value, opts) => {
+    const tt = type === "comment" ? "comment" : "post";
+    let v = 0;
+    if (value === "up") v = 1;
+    else if (value === "down") v = -1;
+    const c = getIMClient2();
+    const res = await c.im.community.vote(tt, id, v);
+    printJson(res, opts);
+  });
+  const my = comm.command("my").description("Your bookmarks (auth)");
+  my.command("bookmarks").description("List bookmarked posts").option("--json", "JSON output").action(async (opts) => {
+    const c = getIMClient2();
+    const res = await c.im.community.listBookmarks({ limit: 30 });
+    printJson(res, opts);
+  });
+}
+
+// src/daemon.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { join as join2, dirname } from "path";
+import * as os from "os";
+import { homedir as homedir2 } from "os";
+import * as http from "http";
+import { createServer } from "http";
+import { execSync } from "child_process";
+import * as TOML from "@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 SYNC_INTERVAL_MS = 6e4;
+var FLUSH_INTERVAL_MS = 3e4;
+var API_TIMEOUT_MS = 1e4;
+var EVENTS_FILE = join2(CACHE_DIR, "events.json");
+var MAX_EVENTS = 1e3;
+function loadConfig() {
+  if (!fs2.existsSync(CONFIG_PATH)) return null;
+  try {
+    const raw = fs2.readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = TOML.parse(raw);
+    const apiKey = parsed?.default?.api_key || "";
+    const baseUrl = parsed?.default?.base_url || "https://prismer.cloud";
+    if (!apiKey) return null;
+    return { apiKey, baseUrl };
+  } catch {
+    return null;
+  }
+}
+function ensureCacheDir() {
+  if (!fs2.existsSync(CACHE_DIR)) {
+    fs2.mkdirSync(CACHE_DIR, { recursive: true });
+  }
+}
+function loadEvents() {
+  try {
+    return JSON.parse(fs2.readFileSync(EVENTS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function appendEvent(event) {
+  const events = loadEvents();
+  events.push(event);
+  if (events.length > MAX_EVENTS) events.splice(0, events.length - MAX_EVENTS);
+  fs2.writeFileSync(EVENTS_FILE, JSON.stringify(events), { encoding: "utf-8", mode: 384 });
+}
+function emitSyncEvent(genesCount) {
+  if (genesCount > 0) {
+    appendEvent({
+      type: "evolution.sync",
+      source: "evolution",
+      priority: "low",
+      title: "Evolution sync complete",
+      body: `${genesCount} genes updated`,
+      timestamp: Date.now()
+    });
+  }
+}
+function readPid() {
+  if (!fs2.existsSync(PID_PATH)) return null;
+  try {
+    const raw = fs2.readFileSync(PID_PATH, "utf-8").trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+function readPort() {
+  if (!fs2.existsSync(PORT_PATH)) return null;
+  try {
+    const raw = fs2.readFileSync(PORT_PATH, "utf-8").trim();
+    const port = parseInt(raw, 10);
+    return isNaN(port) ? null : port;
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writePid(pid) {
+  ensureCacheDir();
+  if (!fs2.existsSync(CONFIG_DIR)) {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs2.writeFileSync(PID_PATH, String(pid), { encoding: "utf-8", mode: 384 });
+}
+function writePort(port) {
+  if (!fs2.existsSync(CONFIG_DIR)) {
+    fs2.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs2.writeFileSync(PORT_PATH, String(port), { encoding: "utf-8", mode: 384 });
+}
+function cleanupPidFiles() {
+  try {
+    if (fs2.existsSync(PID_PATH)) fs2.unlinkSync(PID_PATH);
+  } catch {
+  }
+  try {
+    if (fs2.existsSync(PORT_PATH)) fs2.unlinkSync(PORT_PATH);
+  } catch {
+  }
+}
+async function fetchWithTimeout(url, options, timeoutMs = API_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runDaemonProcess() {
+  const cfg = loadConfig();
+  if (!cfg) {
+    process.stderr.write('[prismer-daemon] No config found. Run "prismer setup" first.\n');
+    process.exit(1);
+  }
+  ensureCacheDir();
+  let lastSync = 0;
+  let syncCount = 0;
+  let evolutionCursor = 0;
+  if (fs2.existsSync(EVOLUTION_CACHE_PATH)) {
+    try {
+      const cached = JSON.parse(fs2.readFileSync(EVOLUTION_CACHE_PATH, "utf-8"));
+      if (typeof cached?.cursor === "number") evolutionCursor = cached.cursor;
+    } catch {
+    }
+  }
+  const server = createServer((req, res) => {
+    if (req.method === "GET" && req.url === "/health") {
+      let outboxSize = 0;
+      if (fs2.existsSync(OUTBOX_PATH)) {
+        try {
+          const entries = JSON.parse(fs2.readFileSync(OUTBOX_PATH, "utf-8"));
+          if (Array.isArray(entries)) outboxSize = entries.length;
+        } catch {
+        }
+      }
+      const body = JSON.stringify({
+        pid: process.pid,
+        uptime: Math.floor(process.uptime()),
+        lastSync,
+        syncCount,
+        outboxSize
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(body);
+    } else if (req.method === "GET" && req.url === "/events") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const events = loadEvents();
+      res.end(JSON.stringify(events.slice(-50)));
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(0, "127.0.0.1", () => {
+    const addr = server.address();
+    const port = addr.port;
+    writePid(process.pid);
+    writePort(port);
+    process.stdout.write(`[prismer-daemon] Started. PID=${process.pid} port=${port}
+`);
+  });
+  const shutdown = () => {
+    process.stdout.write("[prismer-daemon] Shutting down.\n");
+    cleanupPidFiles();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  const doEvolutionSync = async () => {
+    try {
+      const res = await fetchWithTimeout(
+        `${cfg.baseUrl}/api/im/evolution/sync`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`
+          },
+          body: JSON.stringify({ pull: { since: evolutionCursor, scope: "global" } })
+        }
+      );
+      if (res.ok) {
+        const data = await res.json();
+        lastSync = Date.now();
+        syncCount++;
+        if (typeof data?.data?.cursor === "number") {
+          evolutionCursor = data.data.cursor;
+        } else if (typeof data?.cursor === "number") {
+          evolutionCursor = data.cursor;
+        }
+        ensureCacheDir();
+        const pulled = data?.data || data;
+        fs2.writeFileSync(
+          EVOLUTION_CACHE_PATH,
+          JSON.stringify({ cursor: evolutionCursor, lastSync, data: pulled }, null, 2),
+          { encoding: "utf-8", mode: 384 }
+        );
+        emitSyncEvent(pulled?.genes?.length || 0);
+      }
+    } catch {
+    }
+  };
+  const doOutboxFlush = async () => {
+    if (!fs2.existsSync(OUTBOX_PATH)) return;
+    let entries = [];
+    try {
+      entries = JSON.parse(fs2.readFileSync(OUTBOX_PATH, "utf-8"));
+      if (!Array.isArray(entries) || entries.length === 0) return;
+    } catch {
+      return;
+    }
+    try {
+      const res = await fetchWithTimeout(
+        `${cfg.baseUrl}/api/im/evolution/sync`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`
+          },
+          body: JSON.stringify({
+            push: { outcomes: entries },
+            pull: { since: 0 }
+          })
+        }
+      );
+      if (res.ok) {
+        fs2.writeFileSync(OUTBOX_PATH, "[]", { encoding: "utf-8", mode: 384 });
+      }
+    } catch {
+    }
+  };
+  await doEvolutionSync();
+  await doOutboxFlush();
+  const syncTimer = setInterval(doEvolutionSync, SYNC_INTERVAL_MS);
+  const flushTimer = setInterval(doOutboxFlush, FLUSH_INTERVAL_MS);
+  const originalShutdown = shutdown;
+  const fullShutdown = () => {
+    clearInterval(syncTimer);
+    clearInterval(flushTimer);
+    originalShutdown();
+  };
+  process.removeListener("SIGINT", shutdown);
+  process.removeListener("SIGTERM", shutdown);
+  process.on("SIGINT", fullShutdown);
+  process.on("SIGTERM", fullShutdown);
+}
+async function startDaemon() {
+  const existingPid = readPid();
+  if (existingPid !== null && isProcessRunning(existingPid)) {
+    const port = readPort();
+    console.log(`Daemon already running. PID=${existingPid}${port ? ` port=${port}` : ""}`);
+    return;
+  }
+  cleanupPidFiles();
+  const cfg = loadConfig();
+  if (!cfg) {
+    console.error('No API key found. Run "prismer setup" first.');
+    process.exit(1);
+  }
+  if (process.env["PRISMER_DAEMON"] === "1") {
+    await runDaemonProcess();
+    return;
+  }
+  const { spawn } = __require("child_process");
+  const child = spawn(process.execPath, [process.argv[1], "daemon", "start"], {
+    env: { ...process.env, PRISMER_DAEMON: "1" },
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  let waited = 0;
+  while (waited < 3e3) {
+    await new Promise((r) => setTimeout(r, 100));
+    waited += 100;
+    const pid = readPid();
+    const port = readPort();
+    if (pid !== null && port !== null) {
+      console.log(`Daemon started. PID=${pid} port=${port}`);
+      return;
+    }
+  }
+  console.log("Daemon spawned (PID file not yet written \u2014 may take a moment).");
+}
+function stopDaemon() {
+  const pid = readPid();
+  if (pid === null || !isProcessRunning(pid)) {
+    console.log("Daemon: not running");
+    cleanupPidFiles();
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Daemon stopped (PID=${pid})`);
+    cleanupPidFiles();
+  } catch (err) {
+    console.error(`Failed to stop daemon: ${err.message}`);
+  }
+}
+function daemonStatus() {
+  const pid = readPid();
+  if (pid === null || !isProcessRunning(pid)) {
+    console.log("Daemon: not running");
+    cleanupPidFiles();
+    return;
+  }
+  const port = readPort();
+  if (!port) {
+    console.log(`Daemon: running (PID=${pid}, port unknown)`);
+    return;
+  }
+  const req = http.request(
+    { hostname: "127.0.0.1", port, path: "/health", method: "GET", timeout: 3e3 },
+    (res) => {
+      let body = "";
+      res.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      res.on("end", () => {
+        try {
+          const health = JSON.parse(body);
+          console.log(`Daemon: running`);
+          console.log(`  PID:        ${health.pid}`);
+          console.log(`  Uptime:     ${health.uptime}s`);
+          console.log(`  Last sync:  ${health.lastSync ? new Date(health.lastSync).toISOString() : "never"}`);
+          console.log(`  Sync count: ${health.syncCount}`);
+          console.log(`  Outbox:     ${health.outboxSize} entries`);
+          console.log(`  Port:       ${port}`);
+        } catch {
+          console.log(`Daemon: running (PID=${pid} port=${port})`);
+        }
+      });
+    }
+  );
+  req.on("error", () => {
+    console.log(`Daemon: running (PID=${pid} port=${port}, health check failed)`);
+  });
+  req.end();
+}
+function resolveNpxPath() {
+  try {
+    return execSync("which npx", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    for (const p of ["/usr/local/bin/npx", "/opt/homebrew/bin/npx", `${homedir2()}/.nvm/current/bin/npx`]) {
+      try {
+        fs2.accessSync(p);
+        return p;
+      } catch {
+      }
+    }
+    return "npx";
+  }
+}
+function installLaunchd() {
+  const plistPath = join2(homedir2(), "Library", "LaunchAgents", "cloud.prismer.daemon.plist");
+  const npxPath = resolveNpxPath();
+  const nodePath = process.execPath;
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>cloud.prismer.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npxPath}</string>
+    <string>@prismer/sdk</string>
+    <string>daemon</string>
+    <string>start</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PRISMER_DAEMON</key>
+    <string>1</string>
+    <key>PATH</key>
+    <string>${dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join2(homedir2(), ".prismer", "daemon.stdout.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join2(homedir2(), ".prismer", "daemon.stderr.log")}</string>
+</dict>
+</plist>`;
+  fs2.mkdirSync(dirname(plistPath), { recursive: true });
+  fs2.writeFileSync(plistPath, plist, { mode: 384 });
+  try {
+    execSync(`launchctl load ${plistPath}`, { stdio: "pipe" });
+    console.log("[prismer] Daemon service installed and started (launchd)");
+    console.log(`  Plist: ${plistPath}`);
+  } catch {
+    console.log("[prismer] Plist written. Load manually: launchctl load " + plistPath);
+  }
+}
+function uninstallLaunchd() {
+  const plistPath = join2(homedir2(), "Library", "LaunchAgents", "cloud.prismer.daemon.plist");
+  try {
+    execSync(`launchctl unload ${plistPath}`, { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    fs2.unlinkSync(plistPath);
+  } catch {
+  }
+  console.log("[prismer] Daemon service uninstalled (launchd)");
+}
+function installSystemd() {
+  const serviceDir = join2(homedir2(), ".config", "systemd", "user");
+  const servicePath = join2(serviceDir, "prismer-daemon.service");
+  const npxPath = resolveNpxPath();
+  const nodePath = process.execPath;
+  const unit = `[Unit]
+Description=Prismer Daemon \u2014 background evolution sync
+After=network-online.target
+
+[Service]
+Type=simple
+Environment=PRISMER_DAEMON=1
+Environment=PATH=${dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin
+ExecStart=${npxPath} @prismer/sdk daemon start
+Restart=on-failure
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+  fs2.mkdirSync(serviceDir, { recursive: true });
+  fs2.writeFileSync(servicePath, unit, { mode: 420 });
+  try {
+    execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+    execSync("systemctl --user enable prismer-daemon", { stdio: "pipe" });
+    execSync("systemctl --user start prismer-daemon", { stdio: "pipe" });
+    console.log("[prismer] Daemon service installed and started (systemd)");
+    console.log(`  Service: ${servicePath}`);
+  } catch {
+    console.log("[prismer] Service file written. Enable manually:");
+    console.log("  systemctl --user enable --now prismer-daemon");
+  }
+}
+function uninstallSystemd() {
+  try {
+    execSync("systemctl --user stop prismer-daemon", { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    execSync("systemctl --user disable prismer-daemon", { stdio: "pipe" });
+  } catch {
+  }
+  const servicePath = join2(homedir2(), ".config", "systemd", "user", "prismer-daemon.service");
+  try {
+    fs2.unlinkSync(servicePath);
+  } catch {
+  }
+  try {
+    execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+  } catch {
+  }
+  console.log("[prismer] Daemon service uninstalled (systemd)");
+}
+function installDaemonService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    installLaunchd();
+  } else if (platform === "linux") {
+    installSystemd();
+  } else {
+    console.log(`Daemon auto-start not supported on ${platform}. Use: prismer daemon start`);
+  }
+}
+function uninstallDaemonService() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    uninstallLaunchd();
+  } else if (platform === "linux") {
+    uninstallSystemd();
+  } else {
+    console.log(`No daemon service to uninstall on ${platform}.`);
+  }
+}
+if (process.env["PRISMER_DAEMON"] === "1") {
+  runDaemonProcess().catch((err) => {
+    process.stderr.write(`[prismer-daemon] Fatal: ${err.message}
+`);
+    process.exit(1);
+  });
+}
+
+// src/cli.ts
+var cliVersion = "1.7.2";
+try {
+  const pkgPath = path3.join(__dirname, "..", "package.json");
+  const pkg = JSON.parse(fs3.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");
+function ensureConfigDir() {
+  if (!fs3.existsSync(CONFIG_DIR2)) {
+    fs3.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);
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  fs3.writeFileSync(CONFIG_PATH2, TOML2.stringify(config), { encoding: "utf-8", mode: 384 });
+}
+function setNestedValue(obj, dotPath, value) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (current[key] === void 0 || typeof current[key] !== "object") current[key] = {};
+    current = current[key];
+  }
+  current[parts[parts.length - 1]] = 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 } : {} });
+}
+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.');
+    process.exit(1);
+  }
+  const env = cfg?.default?.environment || "production";
+  const baseUrl = cfg?.default?.base_url || "";
+  return new PrismerClient({ apiKey, environment: env, ...baseUrl ? { baseUrl } : {} });
+}
+var program = new Command();
+program.name("prismer").description("Prismer Cloud SDK CLI").version(cliVersion);
+async function verifyAndSaveKey(config, apiKey) {
+  if (!apiKey) {
+    error("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");
+    process.exit(1);
+  }
+  const baseUrl = config.default?.base_url || "https://prismer.cloud";
+  try {
+    const res = await fetch(`${baseUrl}/api/version`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (res.status === 401) {
+      error("API key is invalid or expired.");
+      dim2("  Get a new key at: https://prismer.cloud/setup");
+      process.exit(1);
+    }
+    success("API key verified");
+  } catch (err) {
+    warn(`Could not verify key (${err.message}). Saving anyway.`);
+  }
+  if (!config.default) config.default = {};
+  config.default.api_key = apiKey;
+  if (!config.default.environment) config.default.environment = "production";
+  writeConfig(config);
+  console.log("");
+  success("Saved to ~/.prismer/config.toml");
+  info("You can now use: CLI commands, MCP tools, Claude Code plugin, and all SDKs.");
+  try {
+    installDaemonService();
+  } catch {
+    dim2("Daemon auto-start setup skipped. Run manually: prismer daemon install");
+  }
+}
+function openBrowser(url) {
+  const { execFile } = __require("child_process");
+  if (process.platform === "darwin") {
+    execFile("open", [url], (err) => {
+      if (err) console.warn("Could not open browser. Please open the URL above manually.");
+    });
+  } else if (process.platform === "win32") {
+    execFile("cmd.exe", ["/c", "start", "", url], (err) => {
+      if (err) console.warn("Could not open browser. Please open the URL above manually.");
+    });
+  } else {
+    execFile("xdg-open", [url], (err) => {
+      if (err) console.warn("Could not open browser. Please open the URL above manually.");
+    });
+  }
+}
+async function runSetup(opts, apiKey) {
+  const config = readConfig();
+  if (!config.default) config.default = {};
+  const baseUrl = config.default.base_url || "https://prismer.cloud";
+  if (!opts.force && config.default.api_key?.startsWith("sk-prismer-")) {
+    const masked = config.default.api_key.slice(0, 12) + "..." + config.default.api_key.slice(-4);
+    success(`Already configured: ${masked}`);
+    console.log("");
+    dim2("  To reconfigure, run: prismer setup --force");
+    dim2("  To check status:     prismer status");
+    return;
+  }
+  if (apiKey) {
+    await verifyAndSaveKey(config, apiKey);
+    return;
+  }
+  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");
+      return;
+    }
+    const username = `agent-${Date.now().toString(36)}`;
+    try {
+      const res = await fetch(`${baseUrl}/api/im/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ username, displayName: username, type: "agent" })
+      });
+      const data = await res.json();
+      if (!data.ok) throw new Error(data.error?.message || "Registration failed");
+      if (!config.auth) config.auth = {};
+      config.auth.im_token = data.data?.token;
+      config.auth.im_user_id = data.data?.imUserId || data.data?.userId;
+      config.auth.im_username = data.data?.username || username;
+      writeConfig(config);
+      success("Agent registered with free credits");
+      keyValue({
+        "Username": config.auth.im_username || "",
+        "User ID": config.auth.im_user_id || ""
+      });
+      console.log("");
+      info("For full API access, sign in: prismer setup");
+    } catch (err) {
+      error(`Agent registration failed: ${err.message}`);
+      dim2("  Try signing in instead: prismer setup");
+      process.exit(1);
+    }
+    return;
+  }
+  if (opts.manual) {
+    const setupUrl = `${baseUrl}/setup?utm_source=cli&utm_medium=manual`;
+    info("Opening browser to sign in...");
+    dim2(`  ${setupUrl}`);
+    console.log("");
+    openBrowser(setupUrl);
+    info("After signing in, copy the API key from the page and paste it below.");
+    console.log("");
+    const readline = __require("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("Paste your API key: ", (key) => {
+      rl.close();
+      verifyAndSaveKey(config, key.trim()).catch((err) => {
+        error(`Setup failed: ${err.message}`);
+        process.exit(1);
+      });
+    });
+    return;
+  }
+  const http2 = __require("http");
+  const crypto = __require("crypto");
+  const state = crypto.randomBytes(16).toString("hex");
+  let resolved = false;
+  const server = http2.createServer((req, res) => {
+    const url = new URL(req.url, `http://localhost`);
+    if (url.pathname === "/callback") {
+      const key = url.searchParams.get("key");
+      const returnedState = url.searchParams.get("state");
+      res.writeHead(200, { "Content-Type": "text/html" });
+      if (!key || !returnedState || returnedState !== state) {
+        res.end('<html><head><meta name="referrer" content="no-referrer"></head><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Setup failed</h2><p>Invalid or missing parameters. Please try again.</p></body></html>');
+        return;
+      }
+      if (!key.startsWith("sk-prismer-")) {
+        res.end('<html><head><meta name="referrer" content="no-referrer"></head><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Invalid key</h2><p>The key format is unexpected. Please try again.</p></body></html>');
+        return;
+      }
+      res.end('<html><head><meta name="referrer" content="no-referrer"></head><body style="font-family:system-ui;text-align:center;padding:60px"><h2>Done!</h2><p>API key received. You can close this tab.</p></body></html>');
+      resolved = true;
+      verifyAndSaveKey(config, key).then(() => {
+        server.close();
+        process.exit(0);
+      }).catch((err) => {
+        console.error(`Setup failed: ${err.message}`);
+        server.close();
+        process.exit(1);
+      });
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.listen(0, "127.0.0.1", () => {
+    const port = server.address().port;
+    const callbackUrl = `http://127.0.0.1:${port}/callback`;
+    const setupUrl = `${baseUrl}/setup?callback=${encodeURIComponent(callbackUrl)}&state=${state}&utm_source=cli&utm_medium=auto`;
+    info("Opening browser to sign in...");
+    console.log("");
+    openBrowser(setupUrl);
+    info("Waiting for authentication...");
+    dim2("  (If the browser didn't open, visit this URL manually:)");
+    dim2(`  ${setupUrl}`);
+    console.log("");
+    setTimeout(() => {
+      if (!resolved) {
+        error("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)");
+        server.close();
+        process.exit(1);
+      }
+    }, 5 * 60 * 1e3);
+  });
+}
+program.command("setup [api-key]").description("Set up Prismer \u2014 sign in via browser, register as agent, or provide your API key").option("--manual", "Paste API key manually instead of browser auto-flow").option("--agent", "Register as agent with free credits (no browser, for CI/scripts)").option("--force", "Reconfigure even if already set up").action(async (apiKey, opts) => {
+  await runSetup(opts, apiKey);
+});
+program.command("init [api-key]").description('Alias for "prismer setup" (deprecated, use setup instead)').option("--manual", "Paste API key manually").option("--agent", "Register as agent with free credits").option("--force", "Reconfigure even if already set up").action(async (apiKey, opts) => {
+  warn('"prismer init" is deprecated. Use "prismer setup" instead.');
+  console.log("");
+  await runSetup(opts, apiKey);
+});
+program.command("register <username>").description("Register an IM identity and store the token").option("--type <type>", "Identity type: agent or human", "agent").option("--display-name <name>", "Display name").option("--agent-type <agentType>", "Agent type: assistant, specialist, orchestrator, tool, bot").option("--capabilities <caps>", "Comma-separated capabilities").option("--endpoint <url>", "Webhook endpoint URL").option("--webhook-secret <secret>", "Webhook HMAC secret").action(async (username, opts) => {
+  const config = readConfig();
+  const apiKey = config.default?.api_key;
+  if (!apiKey) {
+    error('No API key. Run "prismer setup" first.');
+    process.exit(1);
+  }
+  const client = new PrismerClient({
+    apiKey,
+    environment: config.default?.environment || "production",
+    baseUrl: config.default?.base_url || void 0
+  });
+  const registerOpts = {
+    type: opts.type,
+    username,
+    displayName: opts.displayName || username
+  };
+  if (opts.agentType) registerOpts.agentType = opts.agentType;
+  if (opts.capabilities) registerOpts.capabilities = opts.capabilities.split(",").map((c) => c.trim());
+  if (opts.endpoint) registerOpts.endpoint = opts.endpoint;
+  if (opts.webhookSecret) registerOpts.webhookSecret = opts.webhookSecret;
+  try {
+    const result = await client.im.account.register(registerOpts);
+    if (!result.ok || !result.data) {
+      error(`Registration failed: ${result.error?.message || "Unknown error"}`);
+      process.exit(1);
+    }
+    const data = result.data;
+    if (!config.auth) config.auth = {};
+    config.auth.im_token = data.token;
+    config.auth.im_user_id = data.imUserId;
+    config.auth.im_username = data.username;
+    config.auth.im_token_expires = data.expiresIn;
+    writeConfig(config);
+    success("Registration successful!");
+    keyValue({
+      "User ID": data.imUserId,
+      "Username": data.username,
+      "Display": data.displayName,
+      "Role": data.role,
+      "New": String(data.isNew)
+    });
+    dim2("  Token stored in ~/.prismer/config.toml");
+  } catch (err) {
+    error(`Registration failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+});
+program.command("status").description("Show current config and live info").action(async () => {
+  const config = readConfig();
+  info("Prismer Status");
+  console.log("");
+  const apiKey = config.default?.api_key;
+  const maskedKey = apiKey ? apiKey.length > 16 ? apiKey.slice(0, 12) + "..." + apiKey.slice(-4) : "***" : "(not set)";
+  keyValue({
+    "API Key": maskedKey,
+    "Environment": config.default?.environment || "(not set)",
+    "Base URL": config.default?.base_url || "(default)"
+  });
+  console.log("");
+  const token = config.auth?.im_token;
+  if (token) {
+    let tokenStatus = "set (expiry unknown)";
+    const expires = config.auth?.im_token_expires;
+    if (expires) {
+      const expiresDate = new Date(expires);
+      if (!isNaN(expiresDate.getTime())) {
+        tokenStatus = expiresDate <= /* @__PURE__ */ new Date() ? "EXPIRED" : `valid (expires ${expiresDate.toISOString()})`;
+      } else {
+        tokenStatus = `set (expires in ${expires})`;
+      }
+    }
+    keyValue({
+      "IM User ID": config.auth?.im_user_id || "(unknown)",
+      "IM Username": config.auth?.im_username || "(unknown)",
+      "IM Token": tokenStatus
+    });
+    console.log("");
+    const me = await withSpinner("Fetching live info", async () => {
+      const client = new PrismerClient({
+        apiKey: token,
+        environment: config.default?.environment || "production",
+        baseUrl: config.default?.base_url || void 0
+      });
+      return client.im.account.me();
+    }).catch((err) => {
+      warn(`Could not fetch live info: ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    });
+    if (me && me.ok && me.data) {
+      keyValue({
+        "Display": me.data.user.displayName,
+        "Role": me.data.user.role,
+        "Credits": String(me.data.credits.balance),
+        "Messages": String(me.data.stats.messagesSent),
+        "Unread": String(me.data.stats.unreadCount)
+      });
+    } else if (me) {
+      warn(`Could not fetch live info: ${me.error?.message || "unknown error"}`);
+    }
+  } else {
+    dim2("  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.');
+    return;
+  }
+  console.log(fs3.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();
+  setNestedValue(config, key, value);
+  writeConfig(config);
+  success(`Set ${key} = ${value}`);
+});
+var tokenCmd = program.command("token").description("Token management");
+tokenCmd.command("refresh").description("Refresh IM JWT token").option("--json", "JSON output").action(async (opts) => {
+  const client = getIMClient();
+  const res = await client.im.account.refreshToken();
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    error(`Token refresh failed: ${JSON.stringify(res.error)}`);
+    process.exit(1);
+  }
+  const data = res.data;
+  const config = readConfig();
+  if (!config.auth) config.auth = {};
+  if (data?.token) {
+    config.auth.im_token = data.token;
+    if (data.expiresIn) config.auth.im_token_expires = data.expiresIn;
+    writeConfig(config);
+    success("Token refreshed and saved.");
+  } else {
+    info("Token refreshed (no new token in response).");
+  }
+});
+register(program, getIMClient, getAPIClient);
+register2(program, getIMClient, getAPIClient);
+register3(program, getIMClient, getAPIClient);
+register4(program, getIMClient, getAPIClient);
+register5(program, getIMClient, getAPIClient);
+register6(program, getIMClient, getAPIClient);
+register7(program, getIMClient, getAPIClient);
+register8(program, getIMClient, getAPIClient);
+register9(program, getIMClient, getAPIClient);
+register10(program, getIMClient, getAPIClient);
+program.command("send").description("Send a direct message (shortcut for: im send)").argument("<user-id>", "Target user/agent ID").argument("<message>", "Message content").option("-t, --type <type>", "Message type: text, markdown, code, etc.", "text").option("--reply-to <id>", "Reply to a message ID").option("--json", "JSON output").action(async (userId, message, opts) => {
+  const client = getIMClient();
+  const sendOpts = {};
+  if (opts.type && opts.type !== "text") sendOpts.type = opts.type;
+  if (opts.replyTo) sendOpts.parentId = opts.replyTo;
+  const res = await withSpinner("Sending message", async () => {
+    return client.im.direct.send(userId, message, sendOpts);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    error(`Send failed: ${JSON.stringify(res.error)}`);
+    process.exit(1);
+  }
+  success(`Message sent (conversation: ${res.data?.conversationId})`);
+});
+program.command("load").description("Load URL(s) \u2192 compressed HQCC (shortcut for: context load)").argument("<urls...>", "One or more URLs").option("-f, --format <fmt>", "Return format: hqcc, raw, both", "hqcc").option("--json", "JSON output").action(async (urls, opts) => {
+  const client = getAPIClient();
+  const input = urls.length === 1 ? urls[0] : urls;
+  const loadOpts = {};
+  if (opts.format) loadOpts.return = { format: opts.format };
+  const res = await withSpinner(`Loading ${urls.length} URL(s)`, async () => {
+    return client.load(input, loadOpts);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.success) {
+    error(res.error?.message || "Load failed");
+    process.exit(1);
+  }
+  const results = res.results || (res.result ? [res.result] : []);
+  for (const r of results) {
+    keyValue({
+      "URL": r.url || "?",
+      "Status": r.cached ? "cached" : "loaded"
+    });
+    if (r.hqcc) console.log(`
+--- HQCC ---
+${r.hqcc.substring(0, 2e3)}`);
+    if (r.raw) console.log(`
+--- Raw ---
+${r.raw.substring(0, 2e3)}`);
+    console.log("");
+  }
+});
+program.command("search").description("Search web content (shortcut for: context search)").argument("<query>", "Search query").option("-k, --top-k <n>", "Number of results", "5").option("--json", "JSON output").action(async (query, opts) => {
+  const client = getAPIClient();
+  const res = await withSpinner(`Searching: ${query}`, async () => {
+    return client.search(query, { topK: parseInt(opts.topK || "5") });
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.success) {
+    error(res.error?.message || "Search failed");
+    process.exit(1);
+  }
+  const results = res.results || [];
+  if (results.length === 0) {
+    warn("No results.");
+    return;
+  }
+  const rows = results.map((r, i) => [
+    String(i + 1),
+    r.url || "(no url)",
+    String(r.ranking?.score ?? "-")
+  ]);
+  table(["#", "URL", "Score"], rows);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    if (r.hqcc) {
+      console.log("");
+      dim2(`  ${i + 1}. ${r.hqcc.substring(0, 200)}`);
+    }
+  }
+});
+program.command("parse").description("Parse a document via OCR (shortcut for: parse run)").argument("<url>", "Document URL").option("-m, --mode <mode>", "Parse mode: fast, hires, auto", "fast").option("--async", "Async mode (returns task ID)").option("--json", "JSON output").action(async (url, opts) => {
+  const client = getAPIClient();
+  const res = await withSpinner(`Parsing: ${url}`, async () => {
+    return client.parsePdf(url, opts.mode);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.success) {
+    error(res.error?.message || "Parse failed");
+    process.exit(1);
+  }
+  if (res.taskId) {
+    keyValue({
+      "Task ID": res.taskId,
+      "Status": res.status || "processing"
+    });
+    console.log("");
+    dim2(`  Check: prismer 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);
+    console.log(content.substring(0, 5e3));
+  }
+});
+var parseCmd = program.commands.find((c) => c.name() === "parse");
+if (parseCmd) {
+}
+program.command("parse-status").description("Check parse task status").argument("<task-id>", "Task ID").option("--json", "JSON output").action(async (taskId, opts) => {
+  const client = getAPIClient();
+  const res = await client.parseStatus(taskId);
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  keyValue({
+    "Task": taskId,
+    "Status": res.status || (res.success ? "complete" : "unknown")
+  });
+});
+program.command("parse-result").description("Get parse result").argument("<task-id>", "Task ID").option("--json", "JSON output").action(async (taskId, opts) => {
+  const client = getAPIClient();
+  const res = await client.parseResult(taskId);
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.success) {
+    error(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) => {
+  const client = getIMClient();
+  const params = { q: query };
+  if (opts.scope) params.scope = opts.scope;
+  if (opts.limit) params.limit = opts.limit;
+  const res = await withSpinner(`Recalling: ${query}`, async () => {
+    return client.im.memory._r("GET", "/api/im/recall", void 0, params);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    error(`Recall failed: ${JSON.stringify(res.error)}`);
+    process.exit(1);
+  }
+  const data = res.data || [];
+  if (data.length === 0) {
+    warn(`No results for "${query}".`);
+    return;
+  }
+  const rows = data.map((item) => [
+    (item.source || "").toUpperCase(),
+    item.title || "?",
+    (item.score || 0).toFixed(2)
+  ]);
+  table(["Source", "Title", "Score"], rows);
+  for (const item of data) {
+    if (item.snippet) {
+      dim2(`  ${item.snippet.substring(0, 200)}`);
+    }
+  }
+});
+program.command("discover").description("Discover available agents (shortcut for: im discover)").option("--type <type>", "Filter by agent type").option("--capability <cap>", "Filter by capability").option("--json", "JSON output").action(async (opts) => {
+  const client = getIMClient();
+  const discoverOpts = {};
+  if (opts.type) discoverOpts.type = opts.type;
+  if (opts.capability) discoverOpts.capability = opts.capability;
+  const res = await withSpinner("Discovering agents", async () => {
+    return client.im.contacts.discover(discoverOpts);
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  if (!res.ok) {
+    error(`Discovery failed: ${JSON.stringify(res.error)}`);
+    process.exit(1);
+  }
+  const agents = res.data || [];
+  if (agents.length === 0) {
+    warn("No agents found.");
+    return;
+  }
+  const rows = agents.map((a) => [
+    a.username || "",
+    a.agentType || "",
+    a.status || "",
+    a.displayName || ""
+  ]);
+  table(["Username", "Type", "Status", "Display Name"], rows);
+});
+program.command("daemon <action>").description("Manage background sync daemon (start|stop|status|install|uninstall)").action(async (action) => {
+  switch (action) {
+    case "start":
+      await startDaemon();
+      break;
+    case "stop":
+      stopDaemon();
+      break;
+    case "status":
+      daemonStatus();
+      break;
+    case "install":
+      installDaemonService();
+      break;
+    case "uninstall":
+      uninstallDaemonService();
+      break;
+    default:
+      error(`Unknown daemon action: ${action}. Use: start, stop, status, install, uninstall`);
+      process.exit(1);
+  }
+});
+displayBanner();
+program.parse(process.argv);
+export {
+  getAPIClient,
+  getIMClient
+};
+t,
+  getIMClient
+};