@clankxyz/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2389 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearConfig: () => clearConfig,
+  config: () => config,
+  fetchRemoteConfig: () => fetchRemoteConfig,
+  getConfig: () => getConfig,
+  getConfigPath: () => getConfigPath,
+  getEffectiveConfig: () => getEffectiveConfig,
+  setConfig: () => setConfig
+});
+import Conf from "conf";
+function getConfig() {
+  return {
+    apiUrl: config.get("apiUrl"),
+    apiKey: config.get("apiKey"),
+    network: config.get("network"),
+    rpcUrl: config.get("rpcUrl"),
+    packageId: config.get("packageId"),
+    walrusAggregator: config.get("walrusAggregator"),
+    walrusPublisher: config.get("walrusPublisher"),
+    agentId: config.get("agentId"),
+    agentName: config.get("agentName"),
+    outputFormat: config.get("outputFormat")
+  };
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function clearConfig() {
+  config.clear();
+}
+function getConfigPath() {
+  return config.path;
+}
+async function fetchRemoteConfig() {
+  if (cachedRemoteConfig) {
+    return cachedRemoteConfig;
+  }
+  const apiUrl = config.get("apiUrl");
+  if (!apiUrl || apiUrl === "http://localhost:3000") {
+    return null;
+  }
+  try {
+    const response = await fetch(`${apiUrl}/api/config`);
+    if (!response.ok) {
+      return null;
+    }
+    cachedRemoteConfig = await response.json();
+    return cachedRemoteConfig;
+  } catch {
+    return null;
+  }
+}
+async function getEffectiveConfig() {
+  const local = getConfig();
+  const remote = await fetchRemoteConfig();
+  return {
+    ...local,
+    // Use local values if set, otherwise fall back to remote
+    packageId: local.packageId || remote?.package_id || "",
+    walrusAggregator: local.walrusAggregator || remote?.walrus.aggregator,
+    walrusPublisher: local.walrusPublisher || remote?.walrus.publisher
+  };
+}
+var cachedRemoteConfig, defaults, config;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    cachedRemoteConfig = null;
+    defaults = {
+      apiUrl: "http://localhost:3000",
+      network: "testnet",
+      outputFormat: "table"
+    };
+    config = new Conf({
+      projectName: "clank-cli",
+      projectVersion: "0.1.0",
+      defaults,
+      schema: {
+        apiUrl: { type: "string" },
+        apiKey: { type: "string" },
+        network: { type: "string", enum: ["mainnet", "testnet", "devnet", "localnet"] },
+        rpcUrl: { type: "string" },
+        packageId: { type: "string" },
+        walrusAggregator: { type: "string" },
+        walrusPublisher: { type: "string" },
+        agentId: { type: "string" },
+        agentName: { type: "string" },
+        outputFormat: { type: "string", enum: ["table", "json"] }
+      }
+    });
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/commands/config.ts
+init_config();
+
+// src/utils.ts
+init_config();
+import chalk from "chalk";
+import ora from "ora";
+import { SuiClient } from "@mysten/sui/client";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { FULLNODE_URLS } from "@clankxyz/shared";
+var colors = {
+  primary: chalk.cyan,
+  success: chalk.green,
+  warning: chalk.yellow,
+  error: chalk.red,
+  muted: chalk.gray,
+  highlight: chalk.bold.white
+};
+function log(message) {
+  console.log(message);
+}
+function success(message) {
+  console.log(colors.success("\u2713"), message);
+}
+function error(message) {
+  console.error(colors.error("\u2717"), message);
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" });
+}
+function formatAddress(address, length = 8) {
+  if (address.length <= length * 2 + 2) return address;
+  return `${address.slice(0, length + 2)}...${address.slice(-length)}`;
+}
+var MIST_PER_SUI = 1e9;
+function formatSui(amount) {
+  const value = typeof amount === "string" ? BigInt(amount) : amount;
+  const sui = Number(value) / MIST_PER_SUI;
+  const formatted = sui.toFixed(4).replace(/\.?0+$/, "");
+  return `${formatted} SUI`;
+}
+function formatTimestamp(timestamp) {
+  const ms = typeof timestamp === "bigint" ? Number(timestamp) : Number(timestamp);
+  return new Date(ms).toLocaleString();
+}
+function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+function formatPercent(value) {
+  if (value === null || value === void 0) return "-";
+  return `${(value * 100).toFixed(1)}%`;
+}
+function table(headers, rows, options = {}) {
+  const maxWidth = options.maxWidth ?? 20;
+  const widths = headers.map(
+    (h, i) => Math.min(
+      maxWidth,
+      Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+    )
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const rowLines = rows.map(
+    (row) => row.map((cell, i) => (cell ?? "").padEnd(widths[i])).join("  ")
+  );
+  return [
+    colors.muted(headerLine),
+    colors.muted(separator),
+    ...rowLines
+  ].join("\n");
+}
+function jsonOutput(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function output(data, tableFormatter) {
+  const config2 = getConfig();
+  if (config2.outputFormat === "json") {
+    jsonOutput(data);
+  } else if (tableFormatter) {
+    log(tableFormatter());
+  } else {
+    jsonOutput(data);
+  }
+}
+function requireConfig(key) {
+  const config2 = getConfig();
+  const value = config2[key];
+  if (!value) {
+    error(`Missing configuration: ${key}`);
+    error(`Run: clank config set ${key} <value>`);
+    process.exit(1);
+  }
+  return value;
+}
+function requireApiKey() {
+  return requireConfig("apiKey");
+}
+function getSuiClient() {
+  const config2 = getConfig();
+  const rpcUrl = config2.rpcUrl ?? FULLNODE_URLS[config2.network] ?? FULLNODE_URLS.mainnet;
+  return new SuiClient({ url: rpcUrl });
+}
+async function loadKeypair(keystorePath, ownerAddress) {
+  const fs = await import("fs");
+  const os = await import("os");
+  const path = await import("path");
+  const defaultPath = path.join(os.homedir(), ".sui", "sui_config", "sui.keystore");
+  const keyPath = keystorePath ?? defaultPath;
+  if (!fs.existsSync(keyPath)) {
+    throw new Error(`Sui keystore not found at: ${keyPath}`);
+  }
+  const keystoreData = fs.readFileSync(keyPath, "utf-8");
+  const keys = JSON.parse(keystoreData);
+  if (keys.length === 0) {
+    throw new Error("No keys found in Sui keystore");
+  }
+  if (ownerAddress) {
+    const normalizedOwner = ownerAddress.toLowerCase();
+    for (const encodedKey of keys) {
+      try {
+        const { secretKey: secretKey2 } = decodeSuiPrivateKey(encodedKey);
+        const keypair = Ed25519Keypair.fromSecretKey(secretKey2);
+        const address = keypair.getPublicKey().toSuiAddress().toLowerCase();
+        if (address === normalizedOwner) {
+          return keypair;
+        }
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`No key found for address: ${ownerAddress}`);
+  }
+  const { secretKey } = decodeSuiPrivateKey(keys[0]);
+  return Ed25519Keypair.fromSecretKey(secretKey);
+}
+
+// src/commands/config.ts
+function registerConfigCommands(program2) {
+  const configCmd = program2.command("config").description("Manage CLI configuration");
+  configCmd.command("show").description("Show current configuration").option("--json", "Output as JSON").action((options) => {
+    const config2 = getConfig();
+    if (options.json) {
+      console.log(JSON.stringify(config2, null, 2));
+      return;
+    }
+    log(colors.primary("\nClank CLI Configuration\n"));
+    log(colors.muted(`Config file: ${getConfigPath()}
+`));
+    const rows = Object.entries(config2).map(([key, value]) => [
+      colors.highlight(key),
+      value !== void 0 ? String(value) : colors.muted("(not set)")
+    ]);
+    log(table(["Key", "Value"], rows));
+    log("");
+  });
+  configCmd.command("get <key>").description("Get a configuration value").action((key) => {
+    const config2 = getConfig();
+    const value = config2[key];
+    if (value === void 0) {
+      error(`Configuration key "${key}" is not set`);
+      process.exit(1);
+    }
+    log(String(value));
+  });
+  configCmd.command("set <key> <value>").description("Set a configuration value").action((key, value) => {
+    const validKeys = [
+      "apiUrl",
+      "apiKey",
+      "network",
+      "rpcUrl",
+      "packageId",
+      "walrusAggregator",
+      "walrusPublisher",
+      "agentId",
+      "agentName",
+      "outputFormat"
+    ];
+    if (!validKeys.includes(key)) {
+      error(`Invalid configuration key: ${key}`);
+      log(`
+Valid keys: ${validKeys.join(", ")}`);
+      process.exit(1);
+    }
+    if (key === "network") {
+      const validNetworks = ["mainnet", "testnet", "devnet", "localnet"];
+      if (!validNetworks.includes(value)) {
+        error(`Invalid network: ${value}`);
+        log(`Valid networks: ${validNetworks.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (key === "outputFormat") {
+      const validFormats = ["table", "json"];
+      if (!validFormats.includes(value)) {
+        error(`Invalid output format: ${value}`);
+        log(`Valid formats: ${validFormats.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    setConfig(key, value);
+    success(`Set ${key} = ${value}`);
+  });
+  configCmd.command("unset <key>").description("Unset a configuration value").action((key) => {
+    setConfig(key, void 0);
+    success(`Unset ${key}`);
+  });
+  configCmd.command("reset").description("Reset all configuration to defaults").option("-y, --yes", "Skip confirmation").action(async (options) => {
+    if (!options.yes) {
+      const prompts = await import("prompts");
+      const { confirm } = await prompts.default({
+        type: "confirm",
+        name: "confirm",
+        message: "Reset all configuration to defaults?",
+        initial: false
+      });
+      if (!confirm) {
+        log("Cancelled");
+        return;
+      }
+    }
+    clearConfig();
+    success("Configuration reset to defaults");
+  });
+  configCmd.command("path").description("Show configuration file path").action(() => {
+    log(getConfigPath());
+  });
+}
+
+// src/client.ts
+init_config();
+import { ClankClient } from "@clankxyz/sdk";
+var clientInstance = null;
+function getClient() {
+  if (clientInstance) return clientInstance;
+  const config2 = getConfig();
+  clientInstance = new ClankClient({
+    apiUrl: config2.apiUrl,
+    apiKey: config2.apiKey,
+    network: config2.network,
+    rpcUrl: config2.rpcUrl,
+    packageId: config2.packageId,
+    walrusAggregator: config2.walrusAggregator,
+    walrusPublisher: config2.walrusPublisher,
+    agentId: config2.agentId
+  });
+  return clientInstance;
+}
+
+// src/commands/agent.ts
+init_config();
+function generateSignatureChallenge(agentId, action, timestamp) {
+  return `Clank Verification
+
+Agent: ${agentId}
+Action: ${action}
+Timestamp: ${timestamp}
+
+Sign this message to verify ownership.`;
+}
+function registerAgentCommands(program2) {
+  const agentCmd = program2.command("agent").description("Manage agents");
+  agentCmd.command("list").description("List all agents").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").action(async (options) => {
+    const spin = spinner("Fetching agents...").start();
+    try {
+      const client = getClient();
+      const result = await client.api.listAgents({
+        page: parseInt(options.page),
+        limit: parseInt(options.limit)
+      });
+      spin.stop();
+      output(result, () => {
+        const rows = result.data.map((agent) => [
+          formatAddress(agent.id),
+          formatAddress(agent.owner),
+          String(agent.skills_count),
+          String(agent.tasks_as_worker),
+          formatPercent(agent.stats?.completion_rate)
+        ]);
+        return `
+${colors.primary("Agents")} (${result.pagination.total} total)
+
+` + table(["ID", "Owner", "Skills", "Tasks Done", "Success"], rows) + `
+
+Page ${result.pagination.page}/${result.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list agents: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("info [id]").description("Get agent details (uses configured agent if no ID)").action(async (id) => {
+    const agentId = id ?? getConfig().agentId;
+    if (!agentId) {
+      error("No agent ID provided. Set one with: clank config set agentId <id>");
+      process.exit(1);
+    }
+    const spin = spinner("Fetching agent...").start();
+    try {
+      const client = getClient();
+      const agent = await client.api.getAgent(agentId);
+      spin.stop();
+      output(agent, () => {
+        let output2 = `
+${colors.primary("Agent Details")}
+
+`;
+        output2 += `${colors.muted("ID:")}          ${agent.id}
+`;
+        output2 += `${colors.muted("Owner:")}       ${agent.owner}
+`;
+        output2 += `${colors.muted("Created:")}     ${formatTimestamp(agent.created_at)}
+`;
+        output2 += `${colors.muted("Metadata:")}    ${agent.metadata_uri ?? "(none)"}
+`;
+        if (agent.skills.length > 0) {
+          output2 += `
+${colors.primary("Skills")} (${agent.skills.length})
+
+`;
+          const skillRows = agent.skills.map((s) => [
+            s.name,
+            s.version,
+            formatSui(s.base_price_mist)
+          ]);
+          output2 += table(["Name", "Version", "Price"], skillRows);
+        }
+        if (agent.badges.length > 0) {
+          output2 += `
+
+${colors.primary("Badges")} (${agent.badges.length})
+
+`;
+          const badgeRows = agent.badges.map((b) => [
+            b.badge_type,
+            `Tier ${b.tier}`,
+            formatTimestamp(b.earned_at)
+          ]);
+          output2 += table(["Type", "Tier", "Earned"], badgeRows);
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get agent: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("stats [id]").description("Get agent statistics").action(async (id) => {
+    const agentId = id ?? getConfig().agentId;
+    if (!agentId) {
+      error("No agent ID provided");
+      process.exit(1);
+    }
+    const spin = spinner("Fetching stats...").start();
+    try {
+      const client = getClient();
+      const stats = await client.api.getAgentStats(agentId);
+      spin.stop();
+      output(stats, () => {
+        let output2 = `
+${colors.primary("Agent Statistics")}
+
+`;
+        output2 += `${colors.highlight("Worker Stats")}
+`;
+        output2 += `  Tasks Completed:  ${stats.workerTasksCompleted}
+`;
+        output2 += `  Tasks Failed:     ${stats.workerTasksFailed}
+`;
+        output2 += `  Tasks Expired:    ${stats.workerTasksExpired}
+`;
+        output2 += `  Total Earned:     ${formatSui(stats.workerTotalEarnedMist)}
+`;
+        output2 += `  Completion Rate:  ${formatPercent(stats.completionRate)}
+`;
+        output2 += `
+${colors.highlight("Requester Stats")}
+`;
+        output2 += `  Tasks Posted:     ${stats.requesterTasksPosted}
+`;
+        output2 += `  Tasks Settled:    ${stats.requesterTasksSettled}
+`;
+        output2 += `  Tasks Cancelled:  ${stats.requesterTasksCancelled}
+`;
+        output2 += `  Tasks Rejected:   ${stats.requesterTasksRejected}
+`;
+        output2 += `  Total Spent:      ${formatSui(stats.requesterTotalSpentMist)}
+`;
+        output2 += `  Rejection Rate:   ${formatPercent(stats.rejectionRate)}
+`;
+        output2 += `
+${colors.highlight("Metrics")}
+`;
+        output2 += `  Unique Partners:  ${stats.uniqueCounterparties}
+`;
+        output2 += `  Flagged:          ${stats.flaggedForAbuse ? colors.error("Yes") : colors.success("No")}
+`;
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get stats: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("use <id>").description("Set the current agent for commands").option("-n, --name <name>", "Agent name for display").action((id, options) => {
+    setConfig("agentId", id);
+    if (options.name) {
+      setConfig("agentName", options.name);
+    }
+    success(`Now using agent: ${formatAddress(id)}`);
+  });
+  agentCmd.command("current").description("Show current agent").action(() => {
+    const config2 = getConfig();
+    if (!config2.agentId) {
+      log("No agent configured. Use: clank agent use <id>");
+      return;
+    }
+    log(`
+Current Agent:`);
+    log(`  ID:   ${config2.agentId}`);
+    if (config2.agentName) {
+      log(`  Name: ${config2.agentName}`);
+    }
+    log("");
+  });
+  agentCmd.command("link <agent-id>").description("Link an on-chain agent to your API key (requires wallet signature)").option("-k, --api-key <key>", "API key to link (uses configured key if not provided)").option("--keystore <path>", "Path to sui.keystore file").action(async (agentId, options) => {
+    const config2 = getConfig();
+    const apiKey = options.apiKey ?? config2.apiKey;
+    if (!apiKey) {
+      error("No API key configured. Set one with: clank config set apiKey <key>");
+      process.exit(1);
+    }
+    log(`
+${colors.primary("Linking Agent to API Key")}
+`);
+    log(`Agent ID: ${formatAddress(agentId)}`);
+    const spin = spinner("Loading Sui keystore...").start();
+    try {
+      const fs = await import("fs");
+      const os = await import("os");
+      const path = await import("path");
+      const keystorePath = options.keystore ?? path.join(os.homedir(), ".sui", "sui_config", "sui.keystore");
+      if (!fs.existsSync(keystorePath)) {
+        spin.stop();
+        error(`Sui keystore not found at: ${keystorePath}`);
+        log(`
+Make sure you have sui CLI installed and configured.`);
+        log(`Or specify a custom path with: --keystore <path>`);
+        process.exit(1);
+      }
+      const keystoreData = fs.readFileSync(keystorePath, "utf-8");
+      const keys = JSON.parse(keystoreData);
+      if (keys.length === 0) {
+        spin.stop();
+        error("No keys found in Sui keystore");
+        process.exit(1);
+      }
+      const { Ed25519Keypair: Ed25519Keypair2 } = await import("@mysten/sui/keypairs/ed25519");
+      const { decodeSuiPrivateKey: decodeSuiPrivateKey2 } = await import("@mysten/sui/cryptography");
+      spin.text = "Fetching agent info...";
+      const agentResponse = await fetch(`${config2.apiUrl}/api/agents/${agentId}`);
+      if (!agentResponse.ok) {
+        spin.stop();
+        const data2 = await agentResponse.json();
+        error(`Failed to fetch agent: ${data2.error}`);
+        log(`
+Make sure the agent has been indexed. Check: clank health`);
+        process.exit(1);
+      }
+      const agentData = await agentResponse.json();
+      const ownerAddress = agentData.agent.owner.toLowerCase();
+      spin.text = "Finding matching key...";
+      let matchingKeypair = null;
+      for (const encodedKey of keys) {
+        try {
+          const { secretKey } = decodeSuiPrivateKey2(encodedKey);
+          const keypair = Ed25519Keypair2.fromSecretKey(secretKey);
+          const address = keypair.getPublicKey().toSuiAddress().toLowerCase();
+          if (address === ownerAddress) {
+            matchingKeypair = keypair;
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (!matchingKeypair) {
+        spin.stop();
+        error(`No key found for agent owner: ${agentData.agent.owner}`);
+        log(`
+Your keystore contains keys for these addresses:`);
+        for (const encodedKey of keys) {
+          try {
+            const { secretKey } = decodeSuiPrivateKey2(encodedKey);
+            const keypair = Ed25519Keypair2.fromSecretKey(secretKey);
+            log(`  - ${keypair.getPublicKey().toSuiAddress()}`);
+          } catch {
+            continue;
+          }
+        }
+        log(`
+Make sure you created the agent with one of these addresses.`);
+        process.exit(1);
+      }
+      spin.text = "Signing verification message...";
+      const timestamp = Date.now();
+      const message = generateSignatureChallenge(agentId, "link_api_key", timestamp);
+      const messageBytes = new TextEncoder().encode(message);
+      const { signature } = await matchingKeypair.signPersonalMessage(messageBytes);
+      spin.text = "Linking agent to API key...";
+      const response = await fetch(`${config2.apiUrl}/api/agents/link`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey
+        },
+        body: JSON.stringify({
+          agent_id: agentId,
+          signature,
+          timestamp
+        })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to link agent: ${data.error}`);
+        if (data.hint) {
+          log(`Hint: ${data.hint}`);
+        }
+        process.exit(1);
+      }
+      setConfig("agentId", agentId);
+      success(`Agent linked successfully!`);
+      log(`
+  Agent ID: ${data.agent_id}`);
+      log(`  Owner:    ${data.agent_owner}`);
+      log(`
+Agent saved to config. Use 'clank agent info' to see details.`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to link agent: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("link-with-sig <agent-id> <signature> <timestamp>").description("Link agent with a pre-signed signature").option("-k, --api-key <key>", "API key to link").action(async (agentId, signature, timestampStr, options) => {
+    const config2 = getConfig();
+    const apiKey = options.apiKey ?? config2.apiKey;
+    if (!apiKey) {
+      error("No API key configured");
+      process.exit(1);
+    }
+    const timestamp = parseInt(timestampStr, 10);
+    if (isNaN(timestamp)) {
+      error("Invalid timestamp");
+      process.exit(1);
+    }
+    const spin = spinner("Linking agent...").start();
+    try {
+      const response = await fetch(`${config2.apiUrl}/api/agents/link`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": apiKey
+        },
+        body: JSON.stringify({
+          agent_id: agentId,
+          signature,
+          timestamp
+        })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to link agent: ${data.error}`);
+        process.exit(1);
+      }
+      setConfig("agentId", agentId);
+      success(`Agent linked successfully!`);
+      log(`
+  Agent ID: ${data.agent_id}`);
+      log(`  Owner:    ${data.agent_owner}`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("register <name>").description("Register a new API key (manual flow - you create agent separately)").option("-u, --api-url <url>", "API URL", "https://clank.xyz").action(async (name, options) => {
+    const spin = spinner("Registering API key...").start();
+    try {
+      const response = await fetch(`${options.apiUrl}/api/agents/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ agent_name: name })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to register: ${data.error}`);
+        process.exit(1);
+      }
+      success(`API key registered!`);
+      log(`
+${colors.warning("\u26A0\uFE0F  Save this key - it cannot be retrieved later!")}
+`);
+      log(`  API Key: ${colors.highlight(data.api_key)}`);
+      log(`  Name:    ${data.agent_name}`);
+      log(`
+Next steps:`);
+      log(`  1. clank config set apiKey ${data.api_key}`);
+      log(`  2. clank config set apiUrl ${options.apiUrl}`);
+      log(`  3. Create agent on-chain using Sui SDK or CLI`);
+      log(`     sui client call --package $TASKNET_PACKAGE_ID --module agent --function create_and_transfer --args '"walrus://your-metadata"'`);
+      log(`  4. clank agent link <agent-id>`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("onboard <name>").description("Onboard a new agent with sponsored gas (no SUI required!)").option("-u, --api-url <url>", "API URL", "https://clank.xyz").option("-m, --metadata <uri>", "Metadata URI").option("-k, --keystore <path>", "Path to save/load keypair").option("-r, --referral <code>", "Referral code from another agent").option("--new-key", "Generate a new keypair").action(async (name, options) => {
+    const fs = await import("fs");
+    const os = await import("os");
+    const path = await import("path");
+    log(`
+${colors.primary("\u{1F680} Sponsored Agent Onboarding")}
+`);
+    let keypair;
+    let savedKeyPath;
+    const { Ed25519Keypair: Ed25519Keypair2 } = await import("@mysten/sui/keypairs/ed25519");
+    if (options.newKey || options.keystore) {
+      const spin2 = spinner("Generating new keypair...").start();
+      keypair = Ed25519Keypair2.generate();
+      spin2.stop();
+      const address = keypair.getPublicKey().toSuiAddress();
+      log(`${colors.success("\u2713")} Generated new keypair`);
+      log(`  Address: ${address}
+`);
+      let keyPath;
+      if (options.keystore) {
+        keyPath = options.keystore;
+      } else {
+        const clankDir = path.join(os.homedir(), ".clank");
+        if (!fs.existsSync(clankDir)) {
+          fs.mkdirSync(clankDir, { recursive: true });
+        }
+        keyPath = path.join(clankDir, `${name}.key`);
+      }
+      const exported = keypair.getSecretKey();
+      fs.writeFileSync(keyPath, exported, { mode: 384 });
+      savedKeyPath = keyPath;
+      log(`${colors.success("\u2713")} Keypair saved to: ${savedKeyPath}
+`);
+    } else {
+      const spin2 = spinner("Loading keypair from Sui keystore...").start();
+      try {
+        const keystorePath = path.join(os.homedir(), ".sui", "sui_config", "sui.keystore");
+        if (!fs.existsSync(keystorePath)) {
+          spin2.stop();
+          error("No Sui keystore found. Use --new-key to generate a new keypair.");
+          process.exit(1);
+        }
+        const keystoreData = fs.readFileSync(keystorePath, "utf-8");
+        const keys = JSON.parse(keystoreData);
+        if (keys.length === 0) {
+          spin2.stop();
+          error("Sui keystore is empty. Use --new-key to generate a new keypair.");
+          process.exit(1);
+        }
+        const { decodeSuiPrivateKey: decodeSuiPrivateKey2 } = await import("@mysten/sui/cryptography");
+        const { secretKey } = decodeSuiPrivateKey2(keys[0]);
+        keypair = Ed25519Keypair2.fromSecretKey(secretKey);
+        spin2.stop();
+        log(`${colors.success("\u2713")} Using keypair from Sui keystore`);
+        log(`  Address: ${keypair.getPublicKey().toSuiAddress()}
+`);
+      } catch (err) {
+        spin2.stop();
+        error(`Failed to load keystore: ${err.message}`);
+        log(`
+Use --new-key to generate a fresh keypair instead.`);
+        process.exit(1);
+      }
+    }
+    const spin = spinner("Creating agent with sponsored gas...").start();
+    try {
+      const publicKeyBase64 = Buffer.from(keypair.getPublicKey().toRawBytes()).toString("base64");
+      const response = await fetch(`${options.apiUrl}/api/agents/onboard`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          agent_name: name,
+          public_key: publicKeyBase64,
+          metadata_uri: options.metadata,
+          referral_code: options.referral
+        })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to onboard: ${data.error}`);
+        if (data.hint) {
+          log(`Hint: ${data.hint}`);
+        }
+        process.exit(1);
+      }
+      setConfig("apiKey", data.api_key);
+      setConfig("apiUrl", options.apiUrl);
+      setConfig("agentId", data.agent_id);
+      setConfig("agentName", name);
+      success(`
+\u{1F389} Agent onboarded successfully!
+`);
+      log(`${colors.warning("\u26A0\uFE0F  Save these credentials - they cannot be retrieved later!")}
+`);
+      log(`  ${colors.muted("Agent ID:")}      ${data.agent_id}`);
+      log(`  ${colors.muted("Address:")}       ${data.agent_address}`);
+      log(`  ${colors.muted("API Key:")}       ${colors.highlight(data.api_key)}`);
+      log(`  ${colors.muted("Referral Code:")} ${data.referral_code}`);
+      log(`  ${colors.muted("Transaction:")}   ${data.transaction_digest}`);
+      if (savedKeyPath) {
+        log(`  ${colors.muted("Private Key:")}   ${savedKeyPath}`);
+      }
+      if (data.referred_by) {
+        log(`  ${colors.muted("Referred By:")}   ${data.referred_by}`);
+      }
+      log(`
+${colors.primary("You're ready to start accepting tasks!")} \u{1F680}
+`);
+      log(`Quick commands:`);
+      log(`  clank skill list     # See available skills`);
+      log(`  clank task list      # See posted tasks`);
+      log(`  clank agent info     # See your agent details`);
+      log(`  clank agent referral # Get your referral link`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  agentCmd.command("referral [id]").description("Get referral info and share link").action(async (id) => {
+    requireApiKey();
+    const agentId = id ?? getConfig().agentId;
+    if (!agentId) {
+      error("No agent ID provided. Set one with: clank config set agentId <id>");
+      process.exit(1);
+    }
+    const spin = spinner("Fetching referral info...").start();
+    try {
+      const config2 = getConfig();
+      const response = await fetch(`${config2.apiUrl}/api/agents/${agentId}/referral`, {
+        headers: {
+          "Authorization": `Bearer ${config2.apiKey}`
+        }
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to get referral info: ${data.error}`);
+        process.exit(1);
+      }
+      output(data, () => {
+        let out = `
+${colors.primary("\u{1F381} Referral Program")}
+
+`;
+        out += `${colors.highlight("Your Referral Code:")}
+`;
+        out += `  ${colors.success(data.referral.code)}
+
+`;
+        out += `${colors.highlight("Share Link:")}
+`;
+        out += `  ${data.referral.link}
+
+`;
+        out += `${colors.highlight("CLI Command (for other agents):")}
+`;
+        out += `  ${data.referral.cli_command}
+
+`;
+        out += `${colors.highlight("Program Info:")}
+`;
+        out += `  ${data.program_info.description}
+
+`;
+        out += `${colors.highlight("Your Stats:")}
+`;
+        out += `  Total Referrals:    ${data.stats.total_referrals}
+`;
+        out += `  Active Referrals:   ${data.stats.active_referrals}
+`;
+        out += `  Referral Earnings:  ${data.stats.referral_earnings_sui} SUI
+`;
+        out += `  Pending Bonus:      ${formatSui(data.stats.pending_bonus_mist)}
+`;
+        out += `  Paid Bonus:         ${formatSui(data.stats.paid_bonus_mist)}
+`;
+        if (data.referred_by) {
+          out += `
+${colors.muted("Referred by:")} ${data.referred_by.name || formatAddress(data.referred_by.agent_id)}
+`;
+        }
+        if (data.referred_agents.length > 0) {
+          out += `
+${colors.highlight("Referred Agents")} (${data.referred_agents.length})
+
+`;
+          const rows = data.referred_agents.slice(0, 10).map((r) => [
+            r.name || formatAddress(r.agent_id),
+            String(r.tasks_completed),
+            formatSui(r.total_earned_mist),
+            r.is_active ? colors.success("Active") : colors.muted("Inactive")
+          ]);
+          out += table(["Agent", "Tasks", "Earned", "Status"], rows);
+        }
+        return out;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get referral info: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/skill.ts
+import { VERIFICATION_LABELS, parseSui } from "@clankxyz/shared";
+import { buildPublishSkillTx } from "@clankxyz/sdk";
+init_config();
+function registerSkillCommands(program2) {
+  const skillCmd = program2.command("skill").alias("skills").description("Manage skills");
+  skillCmd.command("list").description("List available skills").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").option("-n, --name <name>", "Filter by name").option("-a, --agent <id>", "Filter by agent ID").option("-v, --verification <type>", "Filter by verification type (0-2)").option("--deprecated", "Include deprecated skills").option("-s, --sort <field>", "Sort by: published_at, name, price", "published_at").option("-o, --order <dir>", "Sort order: asc, desc", "desc").action(async (options) => {
+    const spin = spinner("Fetching skills...").start();
+    try {
+      const client = getClient();
+      const result = await client.api.listSkills({
+        page: parseInt(options.page),
+        limit: parseInt(options.limit),
+        name: options.name,
+        agentId: options.agent,
+        verificationType: options.verification ? parseInt(options.verification) : void 0,
+        includeDeprecated: options.deprecated,
+        sortBy: options.sort,
+        sortOrder: options.order
+      });
+      spin.stop();
+      output(result, () => {
+        const rows = result.data.map((skill) => [
+          skill.name,
+          skill.version,
+          formatSui(skill.base_price_mist),
+          skill.verification_type_label,
+          formatDuration(skill.timeout_seconds),
+          String(skill.tasks_count)
+        ]);
+        return `
+${colors.primary("Skills")} (${result.pagination.total} total)
+
+` + table(["Name", "Version", "Price", "Verification", "Timeout", "Tasks"], rows) + `
+
+Page ${result.pagination.page}/${result.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list skills: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  skillCmd.command("info <id>").description("Get skill details").action(async (id) => {
+    const spin = spinner("Fetching skill...").start();
+    try {
+      const client = getClient();
+      const skill = await client.api.getSkill(id);
+      spin.stop();
+      output(skill, () => {
+        let output2 = `
+${colors.primary("Skill Details")}
+
+`;
+        output2 += `${colors.muted("ID:")}              ${skill.id}
+`;
+        output2 += `${colors.muted("Name:")}            ${skill.name}
+`;
+        output2 += `${colors.muted("Version:")}         ${skill.version}
+`;
+        output2 += `${colors.muted("Agent:")}           ${formatAddress(skill.agent.id)}
+`;
+        output2 += `${colors.muted("Price:")}           ${formatSui(skill.base_price_mist)}
+`;
+        output2 += `${colors.muted("Worker Bond:")}     ${formatSui(skill.worker_bond_mist)}
+`;
+        output2 += `${colors.muted("Verification:")}    ${skill.verification_type_label}
+`;
+        output2 += `${colors.muted("Timeout:")}         ${formatDuration(skill.timeout_seconds)}
+`;
+        output2 += `${colors.muted("Published:")}       ${formatTimestamp(skill.published_at)}
+`;
+        output2 += `${colors.muted("Deprecated:")}      ${skill.deprecated ? colors.error("Yes") : colors.success("No")}
+`;
+        if (skill.input_schema_hash) {
+          output2 += `${colors.muted("Input Schema:")}    ${skill.input_schema_hash.slice(0, 16)}...
+`;
+        }
+        if (skill.output_schema_hash) {
+          output2 += `${colors.muted("Output Schema:")}   ${skill.output_schema_hash.slice(0, 16)}...
+`;
+        }
+        output2 += `
+${colors.primary("Priority Multipliers")}
+`;
+        const multipliers = skill.priority_multipliers;
+        output2 += `  Standard: ${(multipliers[0] / 1e4).toFixed(1)}x
+`;
+        output2 += `  Priority: ${(multipliers[1] / 1e4).toFixed(1)}x
+`;
+        output2 += `  Urgent:   ${(multipliers[2] / 1e4).toFixed(1)}x
+`;
+        output2 += `
+${colors.primary("Statistics")}
+`;
+        output2 += `  Total Tasks: ${skill.stats.total_tasks}
+`;
+        output2 += `  Templates:   ${skill.stats.templates_count}
+`;
+        if (Object.keys(skill.stats.tasks_by_status).length > 0) {
+          output2 += `
+  ${colors.highlight("Tasks by Status:")}
+`;
+          for (const [status, count] of Object.entries(skill.stats.tasks_by_status)) {
+            output2 += `    ${status}: ${count}
+`;
+          }
+        }
+        if (skill.certifications.length > 0) {
+          output2 += `
+${colors.primary("Certifications")} (${skill.certifications.length})
+
+`;
+          const certRows = skill.certifications.map((c) => [
+            c.certification_type,
+            formatAddress(c.certifier_id),
+            formatTimestamp(c.certified_at)
+          ]);
+          output2 += table(["Type", "Certifier", "Certified"], certRows);
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get skill: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  skillCmd.command("publish").description("Publish a new skill on-chain").requiredOption("-n, --name <name>", "Skill name").requiredOption("-v, --version <version>", "Skill version (e.g., 1.0.0)").requiredOption("-p, --price <sui>", "Base price in SUI (e.g., 0.01)").option("-a, --agent <id>", "Agent ID (uses configured agent if not provided)").option("-t, --timeout <seconds>", "Timeout in seconds", "3600").option("--verification <type>", "Verification type: 0=Deterministic, 1=RequesterConfirm, 2=TimeBound", "1").option("--input-schema <hash>", "SHA256 hash of input JSON schema").option("--output-schema <hash>", "SHA256 hash of output JSON schema").option("--worker-bond <sui>", "Required worker bond in SUI", "0").option("--metadata <uri>", "Metadata URI (e.g., walrus://...)").option("--keystore <path>", "Path to Sui keystore").action(async (options) => {
+    const spin = spinner("Loading configuration...").start();
+    try {
+      const config2 = await getEffectiveConfig();
+      const agentId = options.agent ?? config2.agentId;
+      if (!agentId) {
+        spin.stop();
+        error("No agent ID provided. Set one with: clank config set agentId <id>");
+        process.exit(1);
+      }
+      if (!config2.packageId) {
+        spin.stop();
+        error("Could not get package ID. Make sure you're connected to a Clank API.");
+        log("  Try: clank config set apiUrl https://clank.xyz");
+        process.exit(1);
+      }
+      spin.stop();
+      log(`
+${colors.primary("\u{1F4E6} Publishing Skill On-Chain")}
+`);
+      log(`  Name:          ${options.name}`);
+      log(`  Version:       ${options.version}`);
+      log(`  Price:         ${options.price} SUI`);
+      log(`  Verification:  ${VERIFICATION_LABELS[parseInt(options.verification)] ?? options.verification}`);
+      log(`  Timeout:       ${formatDuration(parseInt(options.timeout))}
+`);
+      spin.start("Loading keypair...");
+      const client = getClient();
+      const agent = await client.api.getAgent(agentId);
+      const ownerAddress = agent.owner;
+      const keypair = await loadKeypair(options.keystore, ownerAddress);
+      spin.text = "Building transaction...";
+      const txConfig = {
+        packageId: config2.packageId
+      };
+      const tx = buildPublishSkillTx(txConfig, {
+        agentId,
+        name: options.name,
+        version: options.version,
+        verificationType: parseInt(options.verification),
+        basePriceMist: parseSui(options.price),
+        workerBondMist: parseSui(options.workerBond ?? "0"),
+        timeoutSeconds: parseInt(options.timeout),
+        inputSchemaHash: options.inputSchema ?? "",
+        outputSchemaHash: options.outputSchema ?? "",
+        metadataUri: options.metadata ?? ""
+      });
+      spin.text = "Signing and executing transaction...";
+      const suiClient = getSuiClient();
+      const result = await suiClient.signAndExecuteTransaction({
+        transaction: tx,
+        signer: keypair,
+        options: {
+          showEffects: true,
+          showObjectChanges: true
+        }
+      });
+      spin.text = "Waiting for confirmation...";
+      await suiClient.waitForTransaction({ digest: result.digest });
+      spin.stop();
+      const skillObject = result.objectChanges?.find(
+        (c) => c.type === "created" && c.objectType?.includes("::skill::Skill")
+      );
+      const skillId = skillObject?.type === "created" ? skillObject.objectId : void 0;
+      success(`Skill published successfully!`);
+      log(`
+  ${colors.muted("Transaction:")} ${result.digest}`);
+      if (skillId) {
+        log(`  ${colors.muted("Skill ID:")}     ${skillId}`);
+      }
+      log(`
+  The indexer will pick up this skill shortly.`);
+      log(`  Run: clank skill info ${skillId ?? "<skill-id>"}`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to publish skill: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  skillCmd.command("search <query>").description("Search skills by name").option("-l, --limit <number>", "Max results", "10").action(async (query, options) => {
+    const spin = spinner("Searching...").start();
+    try {
+      const client = getClient();
+      const result = await client.api.listSkills({
+        name: query,
+        limit: parseInt(options.limit)
+      });
+      spin.stop();
+      if (result.data.length === 0) {
+        log(`
+No skills found matching "${query}"
+`);
+        return;
+      }
+      output(result, () => {
+        const rows = result.data.map((skill) => [
+          skill.name,
+          skill.version,
+          formatSui(skill.base_price_mist),
+          skill.verification_type_label,
+          formatAddress(skill.id)
+        ]);
+        return `
+${colors.primary("Search Results")} for "${query}"
+
+` + table(["Name", "Version", "Price", "Verification", "ID"], rows);
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Search failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/task.ts
+import { STATUS, PRIORITY_LABELS, parseSui as parseSui2 } from "@clankxyz/shared";
+import {
+  buildCreateTaskTx,
+  buildAcceptTaskTx,
+  buildSubmitTaskTx
+} from "@clankxyz/sdk";
+init_config();
+function registerTaskCommands(program2) {
+  const taskCmd = program2.command("task").alias("tasks").description("Manage tasks");
+  taskCmd.command("list").description("List tasks").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").option("-s, --status <status>", "Filter by status (0-9)").option("--skill <id>", "Filter by skill ID").option("--requester <id>", "Filter by requester agent ID").option("--worker <id>", "Filter by worker agent ID").option("--mine", "Show my tasks (as requester or worker)").option("--available", "Show only available tasks (Posted status)").option("--sort <field>", "Sort by: created_at, expires_at, payment, priority", "created_at").option("-o, --order <dir>", "Sort order: asc, desc", "desc").action(async (options) => {
+    const spin = spinner("Fetching tasks...").start();
+    try {
+      const client = getClient();
+      const config2 = getConfig();
+      let requesterId;
+      let workerId;
+      let status;
+      if (options.mine && config2.agentId) {
+        requesterId = config2.agentId;
+      } else {
+        requesterId = options.requester;
+        workerId = options.worker;
+      }
+      if (options.available) {
+        status = STATUS.POSTED;
+      } else if (options.status !== void 0) {
+        status = parseInt(options.status);
+      }
+      const result = await client.api.listTasks({
+        page: parseInt(options.page),
+        limit: parseInt(options.limit),
+        status,
+        skillId: options.skill,
+        requesterId,
+        workerId,
+        sortBy: options.sort,
+        sortOrder: options.order
+      });
+      spin.stop();
+      output(result, () => {
+        const rows = result.data.map((task) => [
+          formatAddress(task.id),
+          task.skill.name,
+          task.status_label,
+          task.priority_label,
+          formatSui(task.payment_amount_mist),
+          formatTimestamp(task.expires_at)
+        ]);
+        return `
+${colors.primary("Tasks")} (${result.pagination.total} total)
+
+` + table(["ID", "Skill", "Status", "Priority", "Payment", "Expires"], rows) + `
+
+Page ${result.pagination.page}/${result.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list tasks: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("info <id>").description("Get task details").action(async (id) => {
+    const spin = spinner("Fetching task...").start();
+    try {
+      const client = getClient();
+      const task = await client.api.getTask(id);
+      spin.stop();
+      output(task, () => {
+        let output2 = `
+${colors.primary("Task Details")}
+
+`;
+        output2 += `${colors.muted("ID:")}              ${task.id}
+`;
+        output2 += `${colors.muted("Skill:")}           ${task.skill.name} v${task.skill.version}
+`;
+        output2 += `${colors.muted("Status:")}          ${getStatusColor(task.status)(task.status_label)}
+`;
+        output2 += `${colors.muted("Priority:")}        ${task.priority_label}
+`;
+        output2 += `${colors.muted("Verification:")}    ${task.verification_type_label}
+`;
+        output2 += `${colors.muted("Payment:")}         ${formatSui(task.payment_amount_mist)}
+`;
+        output2 += `${colors.muted("Worker Bond:")}     ${formatSui(task.worker_bond_amount)}
+`;
+        output2 += `
+${colors.primary("Participants")}
+`;
+        output2 += `${colors.muted("Requester:")}       ${formatAddress(task.requester.id)}
+`;
+        if (task.worker) {
+          output2 += `${colors.muted("Worker:")}          ${formatAddress(task.worker.id)}
+`;
+        }
+        output2 += `
+${colors.primary("Payload")}
+`;
+        output2 += `${colors.muted("Input Ref:")}       ${task.input_payload_ref}
+`;
+        if (task.expected_output_hash) {
+          output2 += `${colors.muted("Expected Hash:")}   ${task.expected_output_hash.slice(0, 32)}...
+`;
+        }
+        if (task.output_ref) {
+          output2 += `${colors.muted("Output Ref:")}      ${task.output_ref}
+`;
+        }
+        if (task.output_hash) {
+          output2 += `${colors.muted("Output Hash:")}     ${task.output_hash.slice(0, 32)}...
+`;
+        }
+        output2 += `
+${colors.primary("Timestamps")}
+`;
+        output2 += `${colors.muted("Created:")}         ${formatTimestamp(task.timestamps.created_at)}
+`;
+        output2 += `${colors.muted("Expires:")}         ${formatTimestamp(task.timestamps.expires_at)}
+`;
+        if (task.timestamps.reserved_at) {
+          output2 += `${colors.muted("Reserved:")}        ${formatTimestamp(task.timestamps.reserved_at)}
+`;
+        }
+        if (task.timestamps.accepted_at) {
+          output2 += `${colors.muted("Accepted:")}        ${formatTimestamp(task.timestamps.accepted_at)}
+`;
+        }
+        if (task.timestamps.submitted_at) {
+          output2 += `${colors.muted("Submitted:")}       ${formatTimestamp(task.timestamps.submitted_at)}
+`;
+        }
+        if (task.timestamps.verified_at) {
+          output2 += `${colors.muted("Verified:")}        ${formatTimestamp(task.timestamps.verified_at)}
+`;
+        }
+        if (task.timestamps.settled_at) {
+          output2 += `${colors.muted("Settled:")}         ${formatTimestamp(task.timestamps.settled_at)}
+`;
+        }
+        if (task.events.length > 0) {
+          output2 += `
+${colors.primary("Recent Events")}
+
+`;
+          const eventRows = task.events.slice(0, 5).map((e) => [
+            e.type,
+            formatTimestamp(e.timestamp_ms),
+            formatAddress(e.tx_digest)
+          ]);
+          output2 += table(["Event", "Time", "TX"], eventRows);
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get task: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("create").description("Create a new task with SUI escrow").requiredOption("-s, --skill <id>", "Skill ID to request").requiredOption("-p, --payment <sui>", "Payment amount in SUI").requiredOption("-i, --input <ref>", "Input payload reference (e.g., walrus://...)").option("-a, --agent <id>", "Requester agent ID (uses configured agent if not provided)").option("--priority <tier>", "Priority: 0=Standard, 1=Priority, 2=Urgent", "0").option("-t, --timeout <seconds>", "Timeout in seconds (0 = use skill default)", "0").option("--expected-hash <hash>", "Expected output hash (for deterministic verification)").option("--keystore <path>", "Path to Sui keystore").action(async (options) => {
+    const spin = spinner("Loading configuration...").start();
+    try {
+      const config2 = await getEffectiveConfig();
+      const agentId = options.agent ?? config2.agentId;
+      if (!agentId) {
+        spin.stop();
+        error("No agent ID provided. Set one with: clank config set agentId <id>");
+        process.exit(1);
+      }
+      if (!config2.packageId) {
+        spin.stop();
+        error("Could not get package ID. Make sure you're connected to a Clank API.");
+        log("  Try: clank config set apiUrl https://clank.xyz");
+        process.exit(1);
+      }
+      spin.stop();
+      log(`
+${colors.primary("\u{1F4CB} Creating Task On-Chain")}
+`);
+      log(`  Skill:     ${formatAddress(options.skill)}`);
+      log(`  Payment:   ${options.payment} SUI`);
+      log(`  Priority:  ${PRIORITY_LABELS[parseInt(options.priority)] ?? options.priority}`);
+      log(`  Input:     ${options.input}
+`);
+      spin.start("Loading keypair...");
+      const client = getClient();
+      const agent = await client.api.getAgent(agentId);
+      const ownerAddress = agent.owner;
+      const keypair = await loadKeypair(options.keystore, ownerAddress);
+      spin.text = "Building transaction...";
+      const txConfig = {
+        packageId: config2.packageId
+      };
+      const tx = buildCreateTaskTx(txConfig, {
+        agentId,
+        skillId: options.skill,
+        inputPayloadRef: options.input,
+        expectedOutputHash: options.expectedHash,
+        paymentAmountMist: parseSui2(options.payment),
+        priorityTier: parseInt(options.priority),
+        timeoutSeconds: parseInt(options.timeout)
+      });
+      spin.text = "Signing and executing transaction...";
+      const suiClient = getSuiClient();
+      const result = await suiClient.signAndExecuteTransaction({
+        transaction: tx,
+        signer: keypair,
+        options: {
+          showEffects: true,
+          showObjectChanges: true
+        }
+      });
+      spin.text = "Waiting for confirmation...";
+      await suiClient.waitForTransaction({ digest: result.digest });
+      spin.stop();
+      const taskObject = result.objectChanges?.find(
+        (c) => c.type === "created" && c.objectType?.includes("::task::Task")
+      );
+      const taskId = taskObject?.type === "created" ? taskObject.objectId : void 0;
+      success(`Task created successfully!`);
+      log(`
+  ${colors.muted("Transaction:")} ${result.digest}`);
+      if (taskId) {
+        log(`  ${colors.muted("Task ID:")}     ${taskId}`);
+      }
+      log(`
+  ${options.payment} SUI has been escrowed.`);
+      log(`  Run: clank task info ${taskId ?? "<task-id>"}`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to create task: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("accept <task-id>").description("Accept a task (become the worker)").option("-a, --agent <id>", "Worker agent ID (uses configured agent if not provided)").option("-b, --bond <sui>", "Worker bond amount in SUI (if required)", "0").option("--keystore <path>", "Path to Sui keystore").action(async (taskId, options) => {
+    const spin = spinner("Loading configuration...").start();
+    try {
+      const config2 = await getEffectiveConfig();
+      const agentId = options.agent ?? config2.agentId;
+      if (!agentId) {
+        spin.stop();
+        error("No agent ID provided. Set one with: clank config set agentId <id>");
+        process.exit(1);
+      }
+      if (!config2.packageId) {
+        spin.stop();
+        error("Could not get package ID. Make sure you're connected to a Clank API.");
+        process.exit(1);
+      }
+      spin.stop();
+      log(`
+${colors.primary("\u{1F527} Accepting Task")}
+`);
+      log(`  Task:  ${formatAddress(taskId)}`);
+      log(`  Agent: ${formatAddress(agentId)}
+`);
+      spin.start("Loading keypair...");
+      const client = getClient();
+      const agent = await client.api.getAgent(agentId);
+      const ownerAddress = agent.owner;
+      const keypair = await loadKeypair(options.keystore, ownerAddress);
+      spin.text = "Building transaction...";
+      const txConfig = {
+        packageId: config2.packageId
+      };
+      const tx = buildAcceptTaskTx(txConfig, {
+        taskId,
+        agentId,
+        bondAmountMist: parseSui2(options.bond ?? "0")
+      });
+      spin.text = "Signing and executing transaction...";
+      const suiClient = getSuiClient();
+      const result = await suiClient.signAndExecuteTransaction({
+        transaction: tx,
+        signer: keypair,
+        options: { showEffects: true }
+      });
+      spin.text = "Waiting for confirmation...";
+      await suiClient.waitForTransaction({ digest: result.digest });
+      spin.stop();
+      success(`Task accepted!`);
+      log(`
+  ${colors.muted("Transaction:")} ${result.digest}`);
+      log(`
+  You can now work on this task.`);
+      log(`  Submit output with: clank task submit ${taskId} --output <ref> --hash <hash>`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to accept task: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("submit <task-id>").description("Submit output for a task").requiredOption("-o, --output <ref>", "Output payload reference (e.g., walrus://...)").requiredOption("--hash <hash>", "SHA256 hash of output (e.g., sha256:...)").option("-a, --agent <id>", "Worker agent ID (uses configured agent if not provided)").option("--keystore <path>", "Path to Sui keystore").action(async (taskId, options) => {
+    const spin = spinner("Loading configuration...").start();
+    try {
+      const config2 = await getEffectiveConfig();
+      const agentId = options.agent ?? config2.agentId;
+      if (!agentId) {
+        spin.stop();
+        error("No agent ID provided. Set one with: clank config set agentId <id>");
+        process.exit(1);
+      }
+      if (!config2.packageId) {
+        spin.stop();
+        error("Could not get package ID. Make sure you're connected to a Clank API.");
+        process.exit(1);
+      }
+      spin.stop();
+      log(`
+${colors.primary("\u{1F4E4} Submitting Task Output")}
+`);
+      log(`  Task:   ${formatAddress(taskId)}`);
+      log(`  Output: ${options.output}`);
+      log(`  Hash:   ${options.hash.slice(0, 24)}...
+`);
+      spin.start("Loading keypair...");
+      const client = getClient();
+      const agent = await client.api.getAgent(agentId);
+      const ownerAddress = agent.owner;
+      const keypair = await loadKeypair(options.keystore, ownerAddress);
+      spin.text = "Building transaction...";
+      const txConfig = {
+        packageId: config2.packageId
+      };
+      const tx = buildSubmitTaskTx(txConfig, {
+        taskId,
+        agentId,
+        outputRef: options.output,
+        outputHash: options.hash
+      });
+      spin.text = "Signing and executing transaction...";
+      const suiClient = getSuiClient();
+      const result = await suiClient.signAndExecuteTransaction({
+        transaction: tx,
+        signer: keypair,
+        options: { showEffects: true }
+      });
+      spin.text = "Waiting for confirmation...";
+      await suiClient.waitForTransaction({ digest: result.digest });
+      spin.stop();
+      success(`Task output submitted!`);
+      log(`
+  ${colors.muted("Transaction:")} ${result.digest}`);
+      log(`
+  For TimeBound verification, payment is auto-released.`);
+      log(`  For RequesterConfirm, wait for requester approval.`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to submit task: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  taskCmd.command("watch").description("Watch for new available tasks").option("--skill <id>", "Filter by skill ID").option("-i, --interval <seconds>", "Poll interval", "30").action(async (options) => {
+    log(`
+${colors.primary("Watching for tasks...")} (Ctrl+C to stop)
+`);
+    const interval = parseInt(options.interval) * 1e3;
+    const seenTasks = /* @__PURE__ */ new Set();
+    const poll = async () => {
+      try {
+        const client = getClient();
+        const result = await client.api.listTasks({
+          status: STATUS.POSTED,
+          skillId: options.skill,
+          limit: 20,
+          sortBy: "created_at",
+          sortOrder: "desc"
+        });
+        for (const task of result.data) {
+          if (!seenTasks.has(task.id)) {
+            seenTasks.add(task.id);
+            log(
+              `${colors.success("NEW")} ${task.skill.name} | ${formatSui(task.payment_amount_mist)} | ${formatAddress(task.id)}`
+            );
+          }
+        }
+      } catch (err) {
+        error(`Poll failed: ${err.message}`);
+      }
+    };
+    await poll();
+    setInterval(poll, interval);
+  });
+}
+function getStatusColor(status) {
+  switch (status) {
+    case STATUS.POSTED:
+    case STATUS.RESERVED:
+      return colors.primary;
+    case STATUS.ACCEPTED:
+    case STATUS.IN_PROGRESS:
+    case STATUS.SUBMITTED:
+      return colors.warning;
+    case STATUS.VERIFIED:
+    case STATUS.SETTLED:
+      return colors.success;
+    case STATUS.CANCELLED:
+    case STATUS.EXPIRED:
+    case STATUS.FAILED:
+      return colors.error;
+    default:
+      return colors.muted;
+  }
+}
+
+// src/commands/health.ts
+function registerHealthCommand(program2) {
+  program2.command("health").description("Check API health status").action(async () => {
+    const spin = spinner("Checking health...").start();
+    try {
+      const client = getClient();
+      const health = await client.api.health();
+      spin.stop();
+      output(health, () => {
+        const statusColor = health.status === "healthy" ? colors.success : health.status === "degraded" ? colors.warning : colors.error;
+        let output2 = `
+${colors.primary("Clank API Health")}
+
+`;
+        output2 += `${colors.muted("Status:")}          ${statusColor(health.status.toUpperCase())}
+`;
+        output2 += `${colors.muted("API Version:")}     ${health.apiVersion}
+`;
+        output2 += `${colors.muted("Last Sync:")}       ${formatTimestamp(health.lastSyncTimestamp)}
+`;
+        output2 += `${colors.muted("Sync Age:")}        ${(health.syncAgeMs / 1e3).toFixed(0)}s
+`;
+        output2 += `${colors.muted("Blocks Behind:")}   ${health.blocksBehind}
+`;
+        output2 += `${colors.muted("Events Total:")}    ${health.eventsProcessedTotal}
+`;
+        if (health.stats) {
+          output2 += `
+${colors.primary("Statistics")}
+`;
+          output2 += `${colors.muted("Agents:")}          ${health.stats.agents}
+`;
+          output2 += `${colors.muted("Skills:")}          ${health.stats.skills}
+`;
+          output2 += `${colors.muted("Tasks:")}           ${health.stats.tasks}
+`;
+        }
+        return output2;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Health check failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/badge.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { BADGE_TIER } from "@clankxyz/shared";
+function registerBadgeCommands(program2) {
+  const badge = program2.command("badge").description("View agent reputation badges");
+  badge.command("list [agentId]").description("List badges for an agent (defaults to current agent)").action(async (agentId) => {
+    const spin = ora2("Fetching badges...").start();
+    try {
+      const client = getClient();
+      const targetId = agentId ?? client.getAgentId();
+      if (!targetId) {
+        spin.fail("No agent specified. Use an agent ID or set an active agent.");
+        process.exit(1);
+      }
+      const agent = await client.api.getAgent(targetId);
+      spin.succeed(`Found ${agent.badges.length} badges`);
+      output(agent.badges, () => {
+        if (agent.badges.length === 0) {
+          return `
+${chalk2.yellow("No badges earned yet.")}
+Complete tasks and verify your identity to earn badges!
+`;
+        }
+        let out = `
+${colors.primary(`Badges for ${targetId.slice(0, 16)}...`)}
+
+`;
+        out += `${colors.muted("Badge".padEnd(22))}  ${colors.muted("Tier".padEnd(10))}  ${colors.muted("Earned At")}
+`;
+        out += `${colors.muted("-".repeat(22))}  ${colors.muted("-".repeat(10))}  ${colors.muted("-".repeat(20))}
+`;
+        for (const b of agent.badges) {
+          const badge2 = (getBadgeIcon(b.badge_type) + " " + formatBadgeType(b.badge_type)).padEnd(22);
+          const tier = getTierDisplay(b.tier).padEnd(10);
+          const earnedAt = new Date(b.earned_at).toLocaleDateString();
+          out += `${badge2}  ${tier}  ${earnedAt}
+`;
+        }
+        const tierCounts = { bronze: 0, silver: 0, gold: 0, platinum: 0 };
+        for (const b of agent.badges) {
+          const tierName = getTierName(b.tier);
+          if (tierName in tierCounts) {
+            tierCounts[tierName]++;
+          }
+        }
+        out += `
+${colors.primary("Summary")}
+`;
+        out += `  ${chalk2.hex("#CD7F32")("\u25CF")} Bronze: ${tierCounts.bronze}  `;
+        out += `${chalk2.gray("\u25CF")} Silver: ${tierCounts.silver}  `;
+        out += `${chalk2.yellow("\u25CF")} Gold: ${tierCounts.gold}  `;
+        out += `${chalk2.magenta("\u25CF")} Platinum: ${tierCounts.platinum}
+`;
+        return out;
+      });
+    } catch (error2) {
+      spin.fail(chalk2.red("Failed to fetch badges"));
+      const err = error2;
+      console.error(chalk2.red(err.message));
+      process.exit(1);
+    }
+  });
+  badge.command("types").description("Show available badge types and how to earn them").action(async () => {
+    let out = `
+${colors.primary("Available Badges")}
+
+`;
+    const badges = [
+      {
+        type: "verified_identity",
+        icon: "\u2713",
+        description: "Verified identity via social or wallet",
+        howToEarn: "Verify your identity using X, GitHub, or wallet signature"
+      },
+      {
+        type: "first_task",
+        icon: "\u{1F3AF}",
+        description: "Completed first task",
+        howToEarn: "Complete your first task as a worker"
+      },
+      {
+        type: "task_completer",
+        icon: "\u{1F4E6}",
+        description: "Task completion milestone",
+        howToEarn: "Complete 10/50/200 tasks for Bronze/Silver/Gold"
+      },
+      {
+        type: "reliable_worker",
+        icon: "\u2B50",
+        description: "High completion rate",
+        howToEarn: "Maintain 90%+ completion rate with 20+ tasks"
+      },
+      {
+        type: "high_earner",
+        icon: "\u{1F4B0}",
+        description: "High earnings milestone",
+        howToEarn: "Earn 100/1K/10K SUI total"
+      },
+      {
+        type: "task_creator",
+        icon: "\u{1F4DD}",
+        description: "Task creation milestone",
+        howToEarn: "Post 10/50/200 tasks for Bronze/Silver/Gold"
+      },
+      {
+        type: "big_spender",
+        icon: "\u{1F48E}",
+        description: "High spending milestone",
+        howToEarn: "Spend 100/1K/10K SUI total"
+      },
+      {
+        type: "networker",
+        icon: "\u{1F310}",
+        description: "Network growth",
+        howToEarn: "Work with 5/25/100 unique counterparties"
+      }
+    ];
+    for (const b of badges) {
+      out += `  ${b.icon} ${chalk2.bold(formatBadgeType(b.type))}
+`;
+      out += `     ${chalk2.gray(b.description)}
+`;
+      out += `     ${chalk2.cyan("How to earn:")} ${b.howToEarn}
+
+`;
+    }
+    out += `${colors.primary("Tiers")}
+`;
+    out += `  ${chalk2.hex("#CD7F32")("\u25CF")} Bronze   - Entry level
+`;
+    out += `  ${chalk2.gray("\u25CF")} Silver   - Intermediate
+`;
+    out += `  ${chalk2.yellow("\u25CF")} Gold     - Advanced
+`;
+    out += `  ${chalk2.magenta("\u25CF")} Platinum - Expert
+`;
+    console.log(out);
+  });
+  badge.command("showcase [agentId]").description("Display badges in a showcase format").action(async (agentId) => {
+    const spin = ora2("Loading showcase...").start();
+    try {
+      const client = getClient();
+      const targetId = agentId ?? client.getAgentId();
+      if (!targetId) {
+        spin.fail("No agent specified.");
+        process.exit(1);
+      }
+      const agent = await client.api.getAgent(targetId);
+      spin.stop();
+      if (agent.badges.length === 0) {
+        console.log(chalk2.yellow("\nNo badges to showcase yet."));
+        return;
+      }
+      const byTier = {};
+      for (const b of agent.badges) {
+        if (!byTier[b.tier]) byTier[b.tier] = [];
+        byTier[b.tier].push(b);
+      }
+      let out = `
+${chalk2.bold.underline("\u{1F3C6} Badge Showcase")}
+
+`;
+      for (const tier of [3, 2, 1, 0]) {
+        const tierBadges = byTier[tier];
+        if (!tierBadges || tierBadges.length === 0) continue;
+        const tierName = getTierName(tier);
+        const tierColor = getTierColor(tier);
+        out += tierColor(chalk2.bold(`\u2501\u2501\u2501 ${tierName.toUpperCase()} \u2501\u2501\u2501`)) + "\n\n";
+        for (const b of tierBadges) {
+          out += `  ${getBadgeIcon(b.badge_type)} ${formatBadgeType(b.badge_type)}
+`;
+        }
+        out += "\n";
+      }
+      const stats = await client.api.getAgentStats(targetId);
+      out += `${colors.primary("Agent Stats")}
+`;
+      out += `  Tasks Completed: ${stats.workerTasksCompleted}
+`;
+      out += `  Tasks Posted: ${stats.requesterTasksPosted}
+`;
+      if (stats.completionRate !== void 0) {
+        out += `  Completion Rate: ${formatPercent(stats.completionRate)}
+`;
+      }
+      console.log(out);
+    } catch (error2) {
+      spin.fail(chalk2.red("Failed to load showcase"));
+      const err = error2;
+      console.error(chalk2.red(err.message));
+      process.exit(1);
+    }
+  });
+}
+function formatBadgeType(type) {
+  return type.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getBadgeIcon(type) {
+  const icons = {
+    verified_identity: "\u2713",
+    first_task: "\u{1F3AF}",
+    task_completer: "\u{1F4E6}",
+    reliable_worker: "\u2B50",
+    high_earner: "\u{1F4B0}",
+    task_creator: "\u{1F4DD}",
+    big_spender: "\u{1F48E}",
+    networker: "\u{1F310}",
+    fast_worker: "\u26A1",
+    top_performer: "\u{1F3C6}"
+  };
+  return icons[type] ?? "\u{1F3C5}";
+}
+function getTierName(tier) {
+  const names = ["bronze", "silver", "gold", "platinum"];
+  return names[tier] ?? "unknown";
+}
+function getTierDisplay(tier) {
+  const tierName = getTierName(tier);
+  const color = getTierColor(tier);
+  return color(tierName.charAt(0).toUpperCase() + tierName.slice(1));
+}
+function getTierColor(tier) {
+  switch (tier) {
+    case BADGE_TIER.BRONZE:
+      return chalk2.hex("#CD7F32");
+    case BADGE_TIER.SILVER:
+      return chalk2.gray;
+    case BADGE_TIER.GOLD:
+      return chalk2.yellow;
+    case 3:
+      return chalk2.magenta;
+    default:
+      return chalk2.white;
+  }
+}
+
+// src/commands/claim.ts
+import { CLAIM_TYPE, CLAIM_TYPE_LABELS, CLAIM_STATUS_LABELS } from "@clankxyz/shared";
+function registerClaimCommands(program2) {
+  const claimCmd = program2.command("claim").description("Identity verification commands");
+  claimCmd.command("generate <type>").description("Generate a verification claim").addHelpText(
+    "after",
+    `
+Claim Types:
+  twitter   - Verify via Twitter/X post
+  moltbook  - Verify via Moltbook post
+  github    - Verify via GitHub Gist
+  wallet    - Verify via wallet signature
+
+Examples:
+  $ clank claim generate twitter
+  $ clank claim generate github
+  $ clank claim generate wallet
+`
+  ).action(async (type) => {
+    await requireApiKey();
+    const client = getClient();
+    const typeMap = {
+      twitter: CLAIM_TYPE.TWITTER,
+      x: CLAIM_TYPE.TWITTER,
+      moltbook: CLAIM_TYPE.MOLTBOOK,
+      github: CLAIM_TYPE.GITHUB,
+      wallet: CLAIM_TYPE.WALLET
+    };
+    const claimType = typeMap[type.toLowerCase()];
+    if (claimType === void 0) {
+      error(`Invalid claim type: ${type}`);
+      log("Valid types: twitter, moltbook, github, wallet");
+      process.exit(1);
+    }
+    const spin = spinner(`Generating ${type} claim...`).start();
+    try {
+      const result = await client.api.generateClaim(claimType);
+      spin.stop();
+      success(`Claim generated successfully!
+`);
+      output(result, () => {
+        let str = `${colors.primary("Claim Details")}
+
+`;
+        str += `  Claim ID:   ${result.claim_id}
+`;
+        str += `  Type:       ${result.claim_type}
+`;
+        str += `  Status:     ${result.status}
+`;
+        str += `  Code:       ${colors.success(result.verification_code)}
+
+`;
+        str += `${colors.primary("Instructions")}
+
+`;
+        str += `  ${result.instructions.split("\n").join("\n  ")}
+
+`;
+        str += `${colors.muted("Next step:")}
+`;
+        str += `  After completing the verification step, run:
+`;
+        str += `  clank claim verify ${result.claim_id} <post_url_or_signature>
+`;
+        return str;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to generate claim: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("verify <claim-id> <proof>").description("Verify a pending claim with post URL or signature").addHelpText(
+    "after",
+    `
+Arguments:
+  claim-id  - The claim ID from 'claim generate'
+  proof     - Post URL (twitter/moltbook/github) or wallet signature
+
+Examples:
+  $ clank claim verify abc123 https://twitter.com/user/status/123456789
+  $ clank claim verify abc123 https://gist.github.com/user/abc123
+  $ clank claim verify abc123 <base64-signature>
+`
+  ).action(async (claimId, proof) => {
+    await requireApiKey();
+    const client = getClient();
+    const spin = spinner("Verifying claim...").start();
+    try {
+      const isUrl = proof.startsWith("http");
+      const result = await client.api.verifyClaim({
+        claimId,
+        postUrl: isUrl ? proof : void 0,
+        signature: !isUrl ? proof : void 0
+      });
+      spin.stop();
+      success(`Claim verified successfully!
+`);
+      output(result, () => {
+        let str = `${colors.primary("Verification Result")}
+
+`;
+        str += `  Claim ID:   ${result.claim_id}
+`;
+        str += `  Type:       ${result.claim_type}
+`;
+        str += `  Handle:     ${result.verified_handle || "N/A"}
+`;
+        str += `  Verified:   ${result.verified_at}
+`;
+        if (result.badge_awarded) {
+          str += `
+  \u{1F3C5} Badge Awarded: ${result.badge_awarded}
+`;
+        }
+        return str;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Verification failed: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("status <claim-id>").description("Get claim status").action(async (claimId) => {
+    const client = getClient();
+    const spin = spinner("Fetching claim...").start();
+    try {
+      const result = await client.api.getClaim(claimId);
+      spin.stop();
+      output(result, () => {
+        let str = `${colors.primary("Claim Details")}
+
+`;
+        str += `  ID:         ${result.id}
+`;
+        str += `  Agent:      ${result.agent_id}
+`;
+        str += `  Type:       ${result.claim_type_label}
+`;
+        str += `  Status:     ${result.status_label}
+`;
+        if (result.verification_code) {
+          str += `  Code:       ${result.verification_code}
+`;
+        }
+        if (result.verified_handle) {
+          str += `  Handle:     ${result.verified_handle}
+`;
+        }
+        if (result.post_url) {
+          str += `  Post URL:   ${result.post_url}
+`;
+        }
+        str += `  Created:    ${result.created_at}
+`;
+        if (result.verified_at) {
+          str += `  Verified:   ${result.verified_at}
+`;
+        }
+        if (result.revoked_at) {
+          str += `  Revoked:    ${result.revoked_at}
+`;
+        }
+        return str;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to fetch claim: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("revoke <claim-id>").description("Revoke a verification claim").action(async (claimId) => {
+    await requireApiKey();
+    const client = getClient();
+    const spin = spinner("Revoking claim...").start();
+    try {
+      const result = await client.api.revokeClaim(claimId);
+      spin.stop();
+      success(result.message);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to revoke claim: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  claimCmd.command("list").description("List your claims (requires linked agent)").action(async () => {
+    await requireApiKey();
+    const client = getClient();
+    const spin = spinner("Fetching claims...").start();
+    try {
+      const config2 = await Promise.resolve().then(() => (init_config(), config_exports)).then((m) => m.getConfig());
+      if (!config2.agentId) {
+        spin.stop();
+        error("No agent linked. Use 'clank agent link' first.");
+        process.exit(1);
+      }
+      const agent = await client.api.getAgent(config2.agentId);
+      spin.stop();
+      if (!agent.claims || agent.claims.length === 0) {
+        log("No claims found for this agent.\n");
+        log("Generate a claim with: clank claim generate <type>");
+        return;
+      }
+      log(`
+${colors.primary("Your Claims")}
+`);
+      const table2 = agent.claims.map((c) => ({
+        ID: c.id.slice(0, 8) + "...",
+        Type: c.claim_type_label || CLAIM_TYPE_LABELS[c.claim_type] || "Unknown",
+        Status: c.status_label || CLAIM_STATUS_LABELS[c.status] || "Unknown",
+        Handle: c.verified_handle || "-",
+        "Verified At": c.verified_at || "-"
+      }));
+      console.table(table2);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list claims: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/proposal.ts
+init_config();
+function registerProposalCommands(program2) {
+  const proposalCmd = program2.command("proposal").description("Manage task proposals (bids)");
+  proposalCmd.command("list").description("List proposals").option("-t, --task <id>", "Filter by task ID").option("-w, --worker <id>", "Filter by worker agent ID").option("-r, --requester <id>", "Filter by requester agent ID").option("-s, --status <status>", "Filter by status (0=pending, 1=accepted, 2=rejected, 3=withdrawn)").option("-m, --mine", "Show only my proposals").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").action(async (options) => {
+    requireApiKey();
+    const config2 = getConfig();
+    const spin = spinner("Fetching proposals...").start();
+    try {
+      const params = new URLSearchParams();
+      if (options.task) params.set("task_id", options.task);
+      if (options.worker) params.set("worker_id", options.worker);
+      if (options.requester) params.set("requester_id", options.requester);
+      if (options.status) params.set("status", options.status);
+      if (options.mine && config2.agentId) params.set("worker_id", config2.agentId);
+      params.set("page", options.page);
+      params.set("limit", options.limit);
+      const response = await fetch(`${config2.apiUrl}/api/proposals?${params.toString()}`, {
+        headers: { "Authorization": `Bearer ${config2.apiKey}` }
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to list proposals: ${data.error}`);
+        process.exit(1);
+      }
+      output(data, () => {
+        if (data.proposals.length === 0) {
+          return `
+${colors.muted("No proposals found")}
+`;
+        }
+        const rows = data.proposals.map((p) => [
+          formatAddress(p.id, 8),
+          p.task.skill.name,
+          `${p.proposed_price_sui} SUI`,
+          p.status_label,
+          formatTimestamp(p.created_at)
+        ]);
+        return `
+${colors.primary("Proposals")} (${data.pagination.total} total)
+
+` + table(["ID", "Skill", "Bid", "Status", "Created"], rows) + `
+
+Page ${data.pagination.page}/${data.pagination.pages}`;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to list proposals: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  proposalCmd.command("create <task-id>").description("Submit a proposal (bid) for a task").option("-p, --price <mist>", "Proposed price in MIST").option("-s, --sui <amount>", "Proposed price in SUI").option("-m, --message <text>", "Message to the requester").option("-t, --time <seconds>", "Estimated time to complete (seconds)").action(async (taskId, options) => {
+    requireApiKey();
+    const config2 = getConfig();
+    if (!config2.agentId) {
+      error("No agent configured. Use: clank agent use <id>");
+      process.exit(1);
+    }
+    let priceMist;
+    if (options.price) {
+      priceMist = BigInt(options.price);
+    } else if (options.sui) {
+      priceMist = BigInt(Math.round(parseFloat(options.sui) * 1e9));
+    } else {
+      error("Price is required. Use --price <mist> or --sui <amount>");
+      process.exit(1);
+    }
+    log(`
+${colors.primary("Creating Proposal")}
+`);
+    log(`Task: ${formatAddress(taskId)}`);
+    log(`Bid: ${formatSui(priceMist.toString())}`);
+    if (options.message) log(`Message: ${options.message}`);
+    if (options.time) log(`Est. Time: ${options.time}s`);
+    const spin = spinner("Submitting proposal...").start();
+    try {
+      const response = await fetch(`${config2.apiUrl}/api/proposals`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config2.apiKey}`
+        },
+        body: JSON.stringify({
+          task_id: taskId,
+          proposed_price_mist: priceMist.toString(),
+          message: options.message,
+          estimated_time_secs: options.time ? parseInt(options.time) : void 0
+        })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to create proposal: ${data.error}`);
+        if (data.proposal_id) {
+          log(`You already have a proposal: ${data.proposal_id}`);
+        }
+        process.exit(1);
+      }
+      success(`Proposal submitted!`);
+      log(`
+  Proposal ID: ${data.proposal.id}`);
+      log(`  Status: ${data.proposal.status_label}`);
+      log(`  Expires: ${formatTimestamp(data.proposal.expires_at)}`);
+      log(`
+The requester will review your proposal and accept or reject it.`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to create proposal: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  proposalCmd.command("info <id>").description("Get proposal details").action(async (id) => {
+    requireApiKey();
+    const config2 = getConfig();
+    const spin = spinner("Fetching proposal...").start();
+    try {
+      const response = await fetch(`${config2.apiUrl}/api/proposals/${id}`, {
+        headers: { "Authorization": `Bearer ${config2.apiKey}` }
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to get proposal: ${data.error}`);
+        process.exit(1);
+      }
+      const p = data.proposal;
+      output(data, () => {
+        let out = `
+${colors.primary("Proposal Details")}
+
+`;
+        out += `${colors.muted("ID:")}             ${p.id}
+`;
+        out += `${colors.muted("Status:")}         ${p.status_label}
+`;
+        out += `${colors.muted("Proposed Price:")} ${p.proposed_price_sui} SUI
+`;
+        out += `${colors.muted("Message:")}        ${p.message || "(none)"}
+`;
+        out += `${colors.muted("Est. Time:")}      ${p.estimated_time_secs ? `${p.estimated_time_secs}s` : "(not specified)"}
+`;
+        out += `${colors.muted("Created:")}        ${formatTimestamp(p.created_at)}
+`;
+        out += `${colors.muted("Expires:")}        ${formatTimestamp(p.expires_at)}
+`;
+        if (p.responded_at) {
+          out += `${colors.muted("Responded:")}      ${formatTimestamp(p.responded_at)}
+`;
+        }
+        out += `
+${colors.highlight("Task")}
+`;
+        out += `  ID: ${p.task.id}
+`;
+        out += `  Skill: ${p.task.skill.name} v${p.task.skill.version}
+`;
+        out += `  Original Price: ${(Number(p.task.original_price_mist) / 1e9).toFixed(4)} SUI
+`;
+        out += `
+${colors.highlight("Worker")}
+`;
+        out += `  ${p.worker.name || formatAddress(p.worker.agent_id)}
+`;
+        out += `
+${colors.highlight("Requester")}
+`;
+        out += `  ${p.task.requester.name || formatAddress(p.task.requester.agent_id)}
+`;
+        return out;
+      });
+    } catch (err) {
+      spin.stop();
+      error(`Failed to get proposal: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  proposalCmd.command("accept <id>").description("Accept a proposal (assigns task to the proposer)").action(async (id) => {
+    requireApiKey();
+    const config2 = getConfig();
+    log(`
+${colors.primary("Accepting Proposal")}
+`);
+    log(`Proposal ID: ${formatAddress(id)}`);
+    const spin = spinner("Accepting proposal...").start();
+    try {
+      const response = await fetch(`${config2.apiUrl}/api/proposals/${id}`, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config2.apiKey}`
+        },
+        body: JSON.stringify({ action: "accept" })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to accept proposal: ${data.error}`);
+        process.exit(1);
+      }
+      success(`Proposal accepted!`);
+      log(`
+  Task: ${data.task_id}`);
+      log(`  Worker: ${formatAddress(data.worker_agent_id)}`);
+      log(`  Price: ${formatSui(data.accepted_price_mist)}`);
+      log(`
+The task is now reserved for the worker.`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to accept proposal: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  proposalCmd.command("reject <id>").description("Reject a proposal").action(async (id) => {
+    requireApiKey();
+    const config2 = getConfig();
+    const spin = spinner("Rejecting proposal...").start();
+    try {
+      const response = await fetch(`${config2.apiUrl}/api/proposals/${id}`, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config2.apiKey}`
+        },
+        body: JSON.stringify({ action: "reject" })
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to reject proposal: ${data.error}`);
+        process.exit(1);
+      }
+      success(`Proposal rejected.`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to reject proposal: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  proposalCmd.command("withdraw <id>").description("Withdraw your proposal").action(async (id) => {
+    requireApiKey();
+    const config2 = getConfig();
+    const spin = spinner("Withdrawing proposal...").start();
+    try {
+      const response = await fetch(`${config2.apiUrl}/api/proposals/${id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${config2.apiKey}` }
+      });
+      const data = await response.json();
+      spin.stop();
+      if (!response.ok) {
+        error(`Failed to withdraw proposal: ${data.error}`);
+        process.exit(1);
+      }
+      success(`Proposal withdrawn.`);
+    } catch (err) {
+      spin.stop();
+      error(`Failed to withdraw proposal: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+init_config();
+var program = new Command();
+var banner = chalk3.cyan(`
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+  \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
+     \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557     \u2588\u2588\u2551   
+     \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D     \u2588\u2588\u2551   
+     \u2588\u2588\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551   
+     \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D   
+`);
+program.name("clank").description("CLI for Clank Protocol - Agent-to-Agent Skills Marketplace").version("0.7.0").addHelpText("beforeAll", banner).option("--json", "Output as JSON").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.json) {
+    const config2 = getConfig();
+    process.env.TASKNET_OUTPUT_FORMAT = "json";
+  }
+});
+registerConfigCommands(program);
+registerAgentCommands(program);
+registerSkillCommands(program);
+registerTaskCommands(program);
+registerBadgeCommands(program);
+registerClaimCommands(program);
+registerProposalCommands(program);
+registerHealthCommand(program);
+program.parse();
+//# sourceMappingURL=index.js.map