@hivemind-os/collective-cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2379 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { pathToFileURL } from "url";
+import { SessionExpiredError } from "@hivemind-os/collective-core";
+
+// src/commands/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { getDefaultIpcPath as getDaemonDefaultIpcPath } from "@hivemind-os/collective-daemon/config";
+import { PaymentRail, NETWORK_PRESETS, getNetworkPreset } from "@hivemind-os/collective-types";
+import yaml from "js-yaml";
+
+// src/utils/output.ts
+var COLORS = {
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  yellow: "\x1B[33m",
+  reset: "\x1B[0m"
+};
+function success(message) {
+  console.log(formatMessage("\u2713", message, COLORS.green));
+}
+function error(message) {
+  console.error(formatMessage("\u2717", message, COLORS.red));
+}
+function info(message) {
+  console.log(formatMessage("\u2139", message, COLORS.blue));
+}
+function warn(message) {
+  console.warn(formatMessage("\u26A0", message, COLORS.yellow));
+}
+function table(headers, rows) {
+  console.log(formatTable(headers, rows));
+}
+function formatTable(headers, rows) {
+  const widths = headers.map((header, index) => {
+    const rowWidth = Math.max(...rows.map((row) => (row[index] ?? "").length), 0);
+    return Math.max(header.length, rowWidth);
+  });
+  const renderRow = (row) => row.map((cell, index) => (cell ?? "").padEnd(widths[index] ?? 0, " ")).join(" | ");
+  return [renderRow(headers), widths.map((width) => "-".repeat(width)).join("-+-"), ...rows.map(renderRow)].join("\n");
+}
+function formatMessage(symbol, message, color) {
+  const prefix = shouldUseColor() ? `${color}${symbol}${COLORS.reset}` : symbol;
+  return `${prefix} ${message}`;
+}
+function shouldUseColor() {
+  return !process.env.NO_COLOR && Boolean(process.stdout.isTTY);
+}
+
+// src/commands/config.ts
+var LOG_LEVELS = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+async function handleConfig(args) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand) {
+    console.log(yaml.dump(redactConfig(serializeConfig(loadMeshConfig())), { lineWidth: 120 }));
+    return 0;
+  }
+  if (subcommand === "path") {
+    console.log(getConfigPath());
+    return 0;
+  }
+  if (subcommand === "set") {
+    const key = rest[0];
+    const rawValue = rest.slice(1).join(" ");
+    if (!key || !rawValue) {
+      throw new Error("Usage: mesh config set <key> <value>");
+    }
+    const config = loadMeshConfig();
+    setNestedValue(config, key, parseConfigValue(rawValue));
+    saveMeshConfig(config);
+    success(`Updated ${key}`);
+    return 0;
+  }
+  throw new Error("Usage: mesh config [path|set <key> <value>]");
+}
+function getMeshDataDir() {
+  return normalizePath(process.env.COLLECTIVE_DATA_DIR ?? join(homedir(), ".hivemind-os/collective"));
+}
+function getConfigPath(configPath) {
+  return normalizePath(configPath ?? join(getMeshDataDir(), "config.yaml"));
+}
+function buildDefaultConfig(dataDir = getMeshDataDir()) {
+  const resolvedDataDir = normalizePath(dataDir);
+  const networkName = process.env.COLLECTIVE_NETWORK;
+  const preset = networkName ? getNetworkPreset(networkName) : NETWORK_PRESETS.testnet;
+  const defaultNetwork = preset ?? NETWORK_PRESETS.testnet;
+  return {
+    network: {
+      rpcUrl: process.env.COLLECTIVE_RPC_URL ?? defaultNetwork.rpcUrl,
+      faucetUrl: defaultNetwork.faucetUrl,
+      packageId: process.env.COLLECTIVE_PACKAGE_ID ?? defaultNetwork.packageId,
+      registryId: process.env.COLLECTIVE_REGISTRY_ID ?? defaultNetwork.registryId
+    },
+    identity: {
+      dataDir: join(resolvedDataDir, "identity")
+    },
+    spending: {
+      defaultRail: PaymentRail.SUI_ESCROW,
+      limits: [{ amount: 1000000000n, interval: "day", currency: "MIST" }]
+    },
+    daemon: {
+      ipcPath: getDaemonDefaultIpcPath(resolvedDataDir),
+      dataDir: resolvedDataDir,
+      pidFile: join(resolvedDataDir, "daemon.pid"),
+      logLevel: normalizeLogLevel(process.env.COLLECTIVE_LOG_LEVEL, "info"),
+      logFile: join(resolvedDataDir, "daemon.log")
+    },
+    blobstore: {
+      type: "filesystem",
+      baseDir: join(resolvedDataDir, "blobs")
+    },
+    indexer: {
+      enabled: Boolean(process.env.COLLECTIVE_INDEXER_URL),
+      url: process.env.COLLECTIVE_INDEXER_URL
+    }
+  };
+}
+function loadMeshConfig(configPath) {
+  const resolvedConfigPath = getConfigPath(configPath);
+  const parsed = loadConfigFile(resolvedConfigPath);
+  const baseDataDir = normalizePath(
+    process.env.COLLECTIVE_DATA_DIR ?? readString(getNestedValue(parsed, "daemon", "dataDir")) ?? dirname(resolvedConfigPath)
+  );
+  const defaults = buildDefaultConfig(baseDataDir);
+  const hasExplicitIpcPath = readString(getNestedValue(parsed, "daemon", "ipcPath")) !== void 0;
+  const config = applyEnvironmentOverrides(mergeConfig(defaults, parsed), { hasExplicitIpcPath });
+  validateConfig(config);
+  if (!existsSync(resolvedConfigPath)) {
+    saveMeshConfig(config, resolvedConfigPath);
+  } else {
+    enforcePrivateFilePermissions(resolvedConfigPath);
+  }
+  return config;
+}
+function saveMeshConfig(config, configPath = getConfigPath()) {
+  const resolvedConfigPath = getConfigPath(configPath);
+  mkdirSync(dirname(resolvedConfigPath), { recursive: true, mode: 448 });
+  writePrivateConfigFile(resolvedConfigPath, yaml.dump(serializeConfig(config), { lineWidth: 120 }));
+  return resolvedConfigPath;
+}
+function writePrivateConfigFile(configPath, contents) {
+  writeFileSync(configPath, contents, { encoding: "utf8", mode: 384 });
+  enforcePrivateFilePermissions(configPath);
+}
+function enforcePrivateFilePermissions(path) {
+  chmodSync(path, 384);
+}
+function serializeConfig(config) {
+  return serializeValue(config);
+}
+function redactConfig(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactConfig(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        /(secret|token|password|private)/i.test(key) ? "<redacted>" : redactConfig(entry)
+      ])
+    );
+  }
+  return value;
+}
+function loadConfigFile(configPath) {
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  const loaded = yaml.load(readFileSync(configPath, "utf8"));
+  return isRecord(loaded) ? loaded : {};
+}
+function mergeConfig(defaults, parsed) {
+  const network = isRecord(parsed.network) ? parsed.network : {};
+  const identity = isRecord(parsed.identity) ? parsed.identity : {};
+  const daemon = isRecord(parsed.daemon) ? parsed.daemon : {};
+  const blobstore = isRecord(parsed.blobstore) ? parsed.blobstore : {};
+  const indexer = isRecord(parsed.indexer) ? parsed.indexer : {};
+  return {
+    network: {
+      rpcUrl: readString(network.rpcUrl) ?? defaults.network.rpcUrl,
+      faucetUrl: readString(network.faucetUrl) ?? defaults.network.faucetUrl,
+      packageId: readHexString(network.packageId) ?? defaults.network.packageId,
+      registryId: readHexString(network.registryId) ?? defaults.network.registryId
+    },
+    identity: {
+      dataDir: normalizePath(readString(identity.dataDir) ?? defaults.identity.dataDir)
+    },
+    spending: normalizeSpendingPolicy(parsed.spending, defaults.spending),
+    daemon: {
+      ipcPath: readString(daemon.ipcPath) ?? defaults.daemon.ipcPath,
+      dataDir: normalizePath(readString(daemon.dataDir) ?? defaults.daemon.dataDir),
+      pidFile: normalizePath(readString(daemon.pidFile) ?? defaults.daemon.pidFile),
+      logLevel: normalizeLogLevel(daemon.logLevel, defaults.daemon.logLevel),
+      logFile: readString(daemon.logFile) ? normalizePath(readString(daemon.logFile)) : defaults.daemon.logFile
+    },
+    blobstore: {
+      type: "filesystem",
+      baseDir: normalizePath(readString(blobstore.baseDir) ?? defaults.blobstore.baseDir)
+    },
+    indexer: {
+      enabled: readBoolean(indexer.enabled) ?? defaults.indexer.enabled,
+      url: readString(indexer.url) ?? defaults.indexer.url
+    }
+  };
+}
+function applyEnvironmentOverrides(config, options = { hasExplicitIpcPath: false }) {
+  const envDataDir = process.env.COLLECTIVE_DATA_DIR ? normalizePath(process.env.COLLECTIVE_DATA_DIR) : void 0;
+  const withDataDir = envDataDir ? {
+    ...config,
+    identity: { dataDir: join(envDataDir, "identity") },
+    daemon: {
+      ...config.daemon,
+      dataDir: envDataDir,
+      pidFile: join(envDataDir, "daemon.pid"),
+      ipcPath: options.hasExplicitIpcPath ? config.daemon.ipcPath : getDaemonDefaultIpcPath(envDataDir),
+      logFile: join(envDataDir, "daemon.log")
+    },
+    blobstore: {
+      type: "filesystem",
+      baseDir: join(envDataDir, "blobs")
+    }
+  } : config;
+  const networkName = process.env.COLLECTIVE_NETWORK;
+  const envPreset = networkName ? getNetworkPreset(networkName) : void 0;
+  const baseNetwork = envPreset ? { ...withDataDir.network, ...envPreset } : withDataDir.network;
+  return {
+    ...withDataDir,
+    network: {
+      ...baseNetwork,
+      rpcUrl: process.env.COLLECTIVE_RPC_URL ?? baseNetwork.rpcUrl,
+      packageId: process.env.COLLECTIVE_PACKAGE_ID ?? baseNetwork.packageId,
+      registryId: process.env.COLLECTIVE_REGISTRY_ID ?? baseNetwork.registryId
+    },
+    daemon: {
+      ...withDataDir.daemon,
+      logLevel: normalizeLogLevel(process.env.COLLECTIVE_LOG_LEVEL, withDataDir.daemon.logLevel)
+    },
+    indexer: {
+      enabled: process.env.COLLECTIVE_INDEXER_URL ? true : withDataDir.indexer.enabled,
+      url: process.env.COLLECTIVE_INDEXER_URL ?? withDataDir.indexer.url
+    }
+  };
+}
+function normalizeSpendingPolicy(value, defaults) {
+  if (!isRecord(value)) {
+    return defaults;
+  }
+  return {
+    defaultRail: normalizeRail(value.defaultRail) ?? defaults.defaultRail,
+    requireConfirmationAbove: value.requireConfirmationAbove === void 0 ? defaults.requireConfirmationAbove : parseBigInt(value.requireConfirmationAbove, "spending.requireConfirmationAbove"),
+    allowlist: Array.isArray(value.allowlist) ? value.allowlist.filter((entry) => typeof entry === "string") : defaults.allowlist,
+    denylist: Array.isArray(value.denylist) ? value.denylist.filter((entry) => typeof entry === "string") : defaults.denylist,
+    limits: Array.isArray(value.limits) && value.limits.length > 0 ? value.limits.map((limit, index) => normalizeSpendingLimit(limit, index)) : defaults.limits
+  };
+}
+function normalizeSpendingLimit(value, index) {
+  if (!isRecord(value)) {
+    throw new Error(`spending.limits[${index}] must be an object.`);
+  }
+  const interval = readString(value.interval);
+  if (!interval || !["transaction", "hour", "day", "month", "lifetime"].includes(interval)) {
+    throw new Error(`spending.limits[${index}].interval is invalid.`);
+  }
+  return {
+    amount: parseBigInt(value.amount, `spending.limits[${index}].amount`),
+    interval,
+    rail: normalizeRail(value.rail),
+    currency: readString(value.currency)?.toUpperCase(),
+    scope: readString(value.scope) ?? void 0
+  };
+}
+function validateConfig(config) {
+  if (!config.network.rpcUrl) {
+    throw new Error("network.rpcUrl is required.");
+  }
+  if (!config.identity.dataDir) {
+    throw new Error("identity.dataDir is required.");
+  }
+  if (!config.daemon.ipcPath || !config.daemon.dataDir || !config.daemon.pidFile) {
+    throw new Error("daemon configuration is incomplete.");
+  }
+  if (!LOG_LEVELS.has(config.daemon.logLevel)) {
+    throw new Error(`Invalid log level: ${config.daemon.logLevel}`);
+  }
+  if (!config.blobstore.baseDir) {
+    throw new Error("blobstore.baseDir is required.");
+  }
+  if (config.indexer.enabled && !config.indexer.url) {
+    throw new Error("indexer.url is required when indexer.enabled is true.");
+  }
+}
+function serializeValue(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => serializeValue(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, serializeValue(entry)]));
+  }
+  return value;
+}
+function normalizeLogLevel(value, fallback) {
+  return typeof value === "string" && LOG_LEVELS.has(value) ? value : fallback;
+}
+function normalizeRail(value) {
+  if (value === PaymentRail.SUI_ESCROW || value === PaymentRail.SUI_TRANSFER || value === PaymentRail.X402_BASE) {
+    return value;
+  }
+  return void 0;
+}
+function parseBigInt(value, field) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error(`${field} must be a non-negative integer.`);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readHexString(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return `0x${value.toString(16)}`;
+  }
+  return void 0;
+}
+function normalizePath(value) {
+  return resolve(expandHome(value));
+}
+function expandHome(value) {
+  if (value === "~") {
+    return homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return join(homedir(), value.slice(2));
+  }
+  return value;
+}
+function getNestedValue(record, ...keys) {
+  let current = record;
+  for (const key of keys) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function parseConfigValue(rawValue) {
+  const parsed = yaml.load(rawValue);
+  return parsed === void 0 ? rawValue : parsed;
+}
+function setNestedValue(target, keyPath, value) {
+  const keys = keyPath.split(".").filter(Boolean);
+  if (keys.length === 0) {
+    throw new Error("Config key is required.");
+  }
+  let current = target;
+  for (const key of keys.slice(0, -1)) {
+    const existing = current[key];
+    if (!isRecord(existing)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/commands/analytics.ts
+async function handleAnalytics(subcommand, args = [], deps = {}) {
+  switch (subcommand) {
+    case "summary":
+      return await showAnalyticsSummary(deps);
+    case "top-providers":
+      return await showTopProviders(args, deps);
+    case "task-volume":
+      return await showTaskVolume(args, deps);
+    default:
+      throw new Error("Usage: mesh analytics <summary|top-providers|task-volume>");
+  }
+}
+async function showAnalyticsSummary(deps) {
+  const data = await queryIndexer(deps, `query AnalyticsSummary {
+    analytics {
+      totalAgents
+      activeAgents
+      totalTasks
+      completedTasks
+      disputedTasks
+      totalVolumeMist
+      marketplace {
+        averageBidCount
+        acceptanceRate
+      }
+    }
+  }`);
+  info("Agentic Mesh analytics summary");
+  table(
+    ["Metric", "Value"],
+    [
+      ["Total Agents", String(data.analytics.totalAgents)],
+      ["Active Agents", String(data.analytics.activeAgents)],
+      ["Total Tasks", String(data.analytics.totalTasks)],
+      ["Completed Tasks", String(data.analytics.completedTasks)],
+      ["Disputed Tasks", String(data.analytics.disputedTasks)],
+      ["Total Volume (MIST)", data.analytics.totalVolumeMist],
+      ["Average Bid Count", data.analytics.marketplace.averageBidCount.toFixed(2)],
+      ["Acceptance Rate", `${(data.analytics.marketplace.acceptanceRate * 100).toFixed(1)}%`]
+    ]
+  );
+  return 0;
+}
+async function showTopProviders(args, deps) {
+  const limit = readNumericFlag(args, "--limit") ?? 10;
+  const sortBy = (readStringFlag(args, "--sort-by") ?? "COMPLETED_TASKS").toUpperCase();
+  const data = await queryIndexer(deps, `query TopProviders($limit: Int, $sortBy: ProviderSortField) {
+    topProviders(limit: $limit, sortBy: $sortBy) {
+      name
+      did
+      completedTasks
+      earningsMist
+      successRate
+      reputation
+    }
+  }`, { limit, sortBy });
+  info(`Top ${data.topProviders.length} providers`);
+  table(
+    ["Name", "DID", "Completed", "Earnings (MIST)", "Success Rate", "Reputation"],
+    data.topProviders.map((provider) => [
+      provider.name,
+      provider.did,
+      String(provider.completedTasks),
+      provider.earningsMist,
+      `${(provider.successRate * 100).toFixed(1)}%`,
+      provider.reputation.toFixed(2)
+    ])
+  );
+  return 0;
+}
+async function showTaskVolume(args, deps) {
+  const period = (readStringFlag(args, "--period") ?? "DAY").toUpperCase();
+  const buckets = readNumericFlag(args, "--buckets") ?? 14;
+  const data = await queryIndexer(
+    deps,
+    `query TaskVolume($period: TimePeriod!, $buckets: Int) {
+      taskVolume(period: $period, buckets: $buckets) {
+        label
+        count
+        volumeMist
+      }
+    }`,
+    { period, buckets }
+  );
+  info(`Task volume by ${period.toLowerCase()}`);
+  table(
+    ["Bucket", "Tasks", "Volume (MIST)"],
+    data.taskVolume.map((bucket) => [bucket.label, String(bucket.count), bucket.volumeMist])
+  );
+  return 0;
+}
+async function queryIndexer(deps, query, variables) {
+  const config = (deps.loadConfig ?? loadMeshConfig)();
+  if (!config.indexer.url) {
+    throw new Error("indexer.url must be configured before using analytics commands.");
+  }
+  const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+  const response = await fetchImpl(config.indexer.url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!response.ok) {
+    throw new Error(`Indexer query failed with status ${response.status}.`);
+  }
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    throw new Error(payload.errors.map((entry) => entry.message ?? "Unknown GraphQL error").join("; "));
+  }
+  if (!payload.data) {
+    throw new Error("Indexer query returned no data.");
+  }
+  return payload.data;
+}
+function readStringFlag(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0) {
+    return void 0;
+  }
+  const value = args[index + 1]?.trim();
+  if (!value) {
+    throw new Error(`Missing value for ${name}.`);
+  }
+  return value;
+}
+function readNumericFlag(args, name) {
+  const value = readStringFlag(args, name);
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${name} must be a positive number.`);
+  }
+  return Math.floor(parsed);
+}
+
+// src/utils/daemon-client.ts
+import net from "net";
+var DaemonClient = class _DaemonClient {
+  constructor(socket) {
+    this.socket = socket;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      this.buffer += chunk.toString();
+      this.drainBuffer();
+    });
+    socket.on("error", (error2) => {
+      this.rejectPending(error2 instanceof Error ? error2 : new Error(String(error2)));
+    });
+    socket.on("close", () => {
+      this.rejectPending(new Error("Daemon IPC connection closed."));
+    });
+  }
+  socket;
+  buffer = "";
+  pending = /* @__PURE__ */ new Map();
+  nextId = 0;
+  static async connect(ipcPath) {
+    const socket = await new Promise((resolvePromise, reject) => {
+      const client = net.connect(ipcPath, () => {
+        client.off("error", reject);
+        resolvePromise(client);
+      });
+      client.once("error", reject);
+    });
+    const daemonClient = new _DaemonClient(socket);
+    await daemonClient.initialize();
+    return daemonClient;
+  }
+  async getStatus() {
+    return await this.callTool("collective_status", {});
+  }
+  async getAuthStatus() {
+    return (await this.request("auth.status")).result;
+  }
+  async triggerReauth() {
+    return (await this.request("auth.reauth")).result;
+  }
+  async close() {
+    if (this.socket.destroyed) {
+      return;
+    }
+    await new Promise((resolvePromise) => {
+      this.socket.once("close", () => {
+        resolvePromise();
+      });
+      this.socket.end();
+      setTimeout(() => {
+        if (!this.socket.destroyed) {
+          this.socket.destroy();
+        }
+      }, 25);
+    });
+  }
+  async initialize() {
+    await this.request("shim_hello", {
+      appName: "mesh-cli",
+      pid: process.pid,
+      profile: process.env.USERPROFILE ?? process.env.HOME
+    });
+    await this.request("initialize", {
+      protocolVersion: "2025-03-26",
+      capabilities: {},
+      clientInfo: {
+        name: "mesh-cli",
+        version: "0.1.0"
+      }
+    });
+    this.socket.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+  }
+  async callTool(name, args) {
+    const response = await this.request("tools/call", {
+      name,
+      arguments: args
+    });
+    const result = asRecord(response.result);
+    return result.structuredContent ?? result;
+  }
+  request(method, params) {
+    const id = `mesh-cli-${++this.nextId}`;
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    return new Promise((resolvePromise, reject) => {
+      this.pending.set(id, { resolve: resolvePromise, reject });
+      this.socket.write(`${JSON.stringify(message)}
+`);
+    }).then((response) => {
+      if (response.error) {
+        throw new Error(response.error.message);
+      }
+      return response;
+    });
+  }
+  drainBuffer() {
+    let newlineIndex = this.buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = this.buffer.slice(0, newlineIndex).trim();
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      if (line) {
+        const message = JSON.parse(line);
+        if ("id" in message && message.id !== null) {
+          const pending = this.pending.get(message.id);
+          if (pending) {
+            this.pending.delete(message.id);
+            pending.resolve(message);
+          }
+        }
+      }
+      newlineIndex = this.buffer.indexOf("\n");
+    }
+  }
+  rejectPending(error2) {
+    for (const [id, pending] of this.pending) {
+      this.pending.delete(id);
+      pending.reject(error2);
+    }
+  }
+};
+async function getDaemonStatus(ipcPath) {
+  const client = await DaemonClient.connect(ipcPath);
+  try {
+    return await client.getStatus();
+  } finally {
+    await client.close();
+  }
+}
+async function getDaemonAuthStatus(ipcPath) {
+  const client = await DaemonClient.connect(ipcPath);
+  try {
+    return await client.getAuthStatus();
+  } finally {
+    await client.close();
+  }
+}
+async function requestDaemonReauth(ipcPath) {
+  const client = await DaemonClient.connect(ipcPath);
+  try {
+    return await client.triggerReauth();
+  } finally {
+    await client.close();
+  }
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Unexpected daemon response payload.");
+  }
+  return value;
+}
+
+// src/commands/auth.ts
+var defaultDeps = {
+  getAuthStatus: getDaemonAuthStatus,
+  triggerReauth: requestDaemonReauth
+};
+async function handleAuth(subcommand, _args = [], deps = defaultDeps) {
+  switch (subcommand) {
+    case "status":
+      return await showAuthStatus(deps);
+    case "reauth":
+      return await triggerReauth(deps);
+    default:
+      throw new Error("Usage: mesh auth <status|reauth>");
+  }
+}
+async function showAuthStatus(deps) {
+  const status = await deps.getAuthStatus(loadMeshConfig().daemon.ipcPath);
+  printAuthStatus(status);
+  return status.authenticated ? 0 : 1;
+}
+async function triggerReauth(deps) {
+  const result = await deps.triggerReauth(loadMeshConfig().daemon.ipcPath);
+  printAuthStatus(result.status);
+  if (result.portalUrl) {
+    if (result.browserOpened) {
+      success(`Opened re-auth portal: ${result.portalUrl}`);
+    } else {
+      warn(`Open the re-auth portal manually: ${result.portalUrl}`);
+    }
+  } else {
+    info("This daemon auth mode does not require browser re-authentication.");
+  }
+  return result.status.authenticated ? 0 : 1;
+}
+function printAuthStatus(status) {
+  const expires = formatExpiry(status.expiresAt);
+  const stateLabel = status.authenticated ? status.state : `${status.state} (action required)`;
+  console.log(`Auth Mode: ${status.authMode}`);
+  console.log(`State: ${stateLabel}`);
+  console.log(`Address: ${status.address ?? "-"}`);
+  console.log(`Expires: ${expires}`);
+  console.log(`Refresh Available: ${status.refreshAvailable ? "yes" : "no"}`);
+  if (status.lastError) {
+    console.log(`Last Error: ${status.lastError}`);
+  }
+}
+function formatExpiry(expiresAt) {
+  if (expiresAt === null) {
+    return "unknown";
+  }
+  return new Date(expiresAt).toISOString();
+}
+
+// src/commands/connect.ts
+import { spawn, spawnSync } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+var require2 = createRequire(import.meta.url);
+async function handleConnect(args) {
+  const shimCommand = resolveShimCommand();
+  if (!shimCommand) {
+    warn("@hivemind-os/collective-shim is not available in this environment.");
+    info("Build or install the shim package, then configure your MCP app to run `mesh connect`.");
+    info("In the meantime, start the background service with `mesh daemon start`.");
+    return 1;
+  }
+  return await new Promise((resolvePromise, reject) => {
+    const child = spawn(shimCommand.command, [...shimCommand.args, ...args], {
+      stdio: "inherit",
+      windowsHide: true
+    });
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      resolvePromise(code ?? 0);
+    });
+  }).catch((caught) => {
+    error(caught instanceof Error ? caught.message : String(caught));
+    return 1;
+  });
+}
+function resolveShimCommand() {
+  try {
+    const packageJsonPath = require2.resolve("@hivemind-os/collective-shim/package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+    const binField = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.["mesh-shim"] ?? Object.values(packageJson.bin ?? {})[0];
+    if (!binField) {
+      return void 0;
+    }
+    const entryPath = resolve2(dirname2(packageJsonPath), binField);
+    return {
+      command: process.execPath,
+      args: [entryPath]
+    };
+  } catch {
+    const onPath = process.platform === "win32" ? findOnPath("mesh-shim.cmd") ?? findOnPath("mesh-shim") : findOnPath("mesh-shim");
+    return onPath ? { command: onPath, args: [] } : void 0;
+  }
+}
+function findOnPath(command) {
+  const checker = process.platform === "win32" ? "where.exe" : "which";
+  const result = spawnSync(checker, [command], { encoding: "utf8", windowsHide: true });
+  if (result.status !== 0) {
+    return void 0;
+  }
+  return result.stdout.split(/\r?\n/).map((entry) => entry.trim()).find(Boolean);
+}
+
+// src/commands/daemon.ts
+import { spawn as spawn2 } from "child_process";
+import { createRequire as createRequire2 } from "module";
+import { existsSync as existsSync2, readFileSync as readFileSync3, rmSync } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+var require3 = createRequire2(import.meta.url);
+var defaultDeps2 = {
+  spawnProcess: (command, args, options) => spawn2(command, args, options),
+  resolveDaemonCommand,
+  getStatus: getDaemonStatus,
+  killProcess: (pid, signal) => {
+    process.kill(pid, signal);
+  },
+  isProcessRunning,
+  sleep: (ms) => new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms);
+  })
+};
+async function handleDaemon(subcommand, args = [], deps = defaultDeps2) {
+  void args;
+  switch (subcommand) {
+    case "start":
+      return await startDaemon(deps);
+    case "stop":
+      return await stopDaemon(deps);
+    case "status":
+      return await statusDaemon(deps);
+    default:
+      throw new Error("Usage: mesh daemon <start|stop|status>");
+  }
+}
+async function startDaemon(deps) {
+  const config = loadMeshConfig();
+  const pid = readPid(config.daemon.pidFile);
+  if (pid && deps.isProcessRunning(pid)) {
+    info("Daemon is already running.");
+    return await statusDaemon(deps);
+  }
+  if (pid && !deps.isProcessRunning(pid)) {
+    rmSync(config.daemon.pidFile, { force: true });
+  }
+  const daemonCommand = await deps.resolveDaemonCommand();
+  const child = deps.spawnProcess(daemonCommand.command, daemonCommand.args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: process.env
+  });
+  child.unref();
+  const ready = await waitForReady(config.daemon.ipcPath, deps);
+  if (!ready) {
+    error("Daemon did not become ready in time.");
+    return 1;
+  }
+  success(`Daemon started${child.pid ? ` (pid ${child.pid})` : ""}.`);
+  const status = await deps.getStatus(config.daemon.ipcPath);
+  printStatus(status);
+  return 0;
+}
+async function stopDaemon(deps) {
+  const config = loadMeshConfig();
+  const pid = readPid(config.daemon.pidFile);
+  if (!pid) {
+    info("Daemon is not running.");
+    return 1;
+  }
+  if (!deps.isProcessRunning(pid)) {
+    rmSync(config.daemon.pidFile, { force: true });
+    info("Daemon is not running.");
+    return 1;
+  }
+  deps.killProcess(pid, "SIGTERM");
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    await deps.sleep(100);
+    if (!deps.isProcessRunning(pid)) {
+      rmSync(config.daemon.pidFile, { force: true });
+      success("Daemon stopped.");
+      return 0;
+    }
+  }
+  deps.killProcess(pid, "SIGKILL");
+  for (let attempt = 0; attempt < 10; attempt += 1) {
+    await deps.sleep(100);
+    if (!deps.isProcessRunning(pid)) {
+      rmSync(config.daemon.pidFile, { force: true });
+      success("Daemon stopped.");
+      return 0;
+    }
+  }
+  error("Unable to stop the daemon process.");
+  return 1;
+}
+async function statusDaemon(deps) {
+  const config = loadMeshConfig();
+  const pid = readPid(config.daemon.pidFile);
+  if (!pid || !deps.isProcessRunning(pid)) {
+    if (pid && !deps.isProcessRunning(pid)) {
+      rmSync(config.daemon.pidFile, { force: true });
+    }
+    info("Daemon is not running.");
+    return 1;
+  }
+  try {
+    const status = await deps.getStatus(config.daemon.ipcPath);
+    success("Daemon is running.");
+    printStatus(status);
+    return 0;
+  } catch (caught) {
+    warn("Daemon process exists, but IPC status could not be fetched.");
+    console.log(`PID: ${pid}`);
+    console.log(`PID file: ${config.daemon.pidFile}`);
+    console.log(`Reason: ${caught instanceof Error ? caught.message : String(caught)}`);
+    return 1;
+  }
+}
+async function waitForReady(ipcPath, deps) {
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    try {
+      await deps.getStatus(ipcPath);
+      return true;
+    } catch {
+      await deps.sleep(100);
+    }
+  }
+  return false;
+}
+function printStatus(status) {
+  console.log(`DID: ${status.did}`);
+  console.log(`Address: ${status.address}`);
+  console.log(`Uptime: ${formatDuration(status.uptimeMs)}`);
+  console.log(`Connected Apps: ${status.connectedApps.length}`);
+  if (status.connectedApps.length > 0) {
+    table(
+      ["App", "PID", "Profile", "Connected"],
+      status.connectedApps.map((app) => [
+        app.appName ?? "-",
+        app.pid?.toString() ?? "-",
+        app.profile ?? "-",
+        new Date(app.connectedAt).toISOString()
+      ])
+    );
+  }
+}
+async function resolveDaemonCommand() {
+  try {
+    const packageJsonPath = require3.resolve("@hivemind-os/collective-daemon/package.json");
+    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+    const entryPath = resolve3(dirname3(packageJsonPath), packageJson.main ?? "dist/index.js");
+    return {
+      command: process.execPath,
+      args: [entryPath]
+    };
+  } catch {
+    const fallback = resolve3(process.cwd(), "packages", "daemon", "dist", "index.js");
+    if (existsSync2(fallback)) {
+      return {
+        command: process.execPath,
+        args: [fallback]
+      };
+    }
+    throw new Error("Unable to locate @hivemind-os/collective-daemon. Run pnpm install && pnpm run build first.");
+  }
+}
+function readPid(pidFile) {
+  if (!existsSync2(pidFile)) {
+    return void 0;
+  }
+  const pid = Number.parseInt(readFileSync3(pidFile, "utf8").trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (caught) {
+    return caught.code !== "ESRCH";
+  }
+}
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const parts = [];
+  if (hours > 0) {
+    parts.push(`${hours}h`);
+  }
+  if (minutes > 0 || hours > 0) {
+    parts.push(`${minutes}m`);
+  }
+  parts.push(`${seconds}s`);
+  return parts.join(" ");
+}
+
+// src/commands/discover.ts
+import { MeshSuiClient as MeshSuiClient2, RegistryClient } from "@hivemind-os/collective-core";
+
+// src/commands/wallet.ts
+import { createDID, loadOrCreateKeypair, MeshSuiClient } from "@hivemind-os/collective-core";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+async function handleWallet(subcommand, args = []) {
+  void args;
+  switch (subcommand) {
+    case "balance":
+      return await showBalance();
+    case "fund":
+      return await fundWallet();
+    case "address":
+      return await showAddress();
+    default:
+      throw new Error("Usage: mesh wallet <balance|fund|address>");
+  }
+}
+function formatMistToSui(balanceMist) {
+  const whole = balanceMist / 1000000000n;
+  const fraction = balanceMist % 1000000000n;
+  if (fraction === 0n) {
+    return whole.toString();
+  }
+  const fractionText = fraction.toString().padStart(9, "0").replace(/0+$/, "");
+  return `${whole.toString()}.${fractionText}`;
+}
+function parseSuiToMist(input) {
+  const trimmed = input.trim();
+  if (!/^\d+(?:\.\d{1,9})?$/.test(trimmed)) {
+    throw new Error(`Invalid SUI amount: ${input}`);
+  }
+  const [whole, fraction = ""] = trimmed.split(".");
+  return BigInt(whole) * 1000000000n + BigInt(fraction.padEnd(9, "0"));
+}
+async function showBalance() {
+  const { config, address } = await loadWalletContext();
+  const suiClient = new MeshSuiClient(config.network);
+  const balanceMist = await suiClient.getBalance(address);
+  success(`Wallet balance for ${address}`);
+  console.log(`MIST: ${balanceMist.toString()}`);
+  console.log(`SUI: ${formatMistToSui(balanceMist)}`);
+  return 0;
+}
+async function fundWallet() {
+  const { config, address, did } = await loadWalletContext();
+  info(`Requesting faucet funds for ${address}`);
+  const faucetUrls = [config.network.faucetUrl, `${config.network.faucetUrl.replace(/\/$/, "")}/gas`].filter(Boolean);
+  let funded = false;
+  for (const faucetUrl of faucetUrls) {
+    try {
+      const response = await fetch(faucetUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          FixedAmountRequest: {
+            recipient: address
+          }
+        })
+      });
+      if (response.ok) {
+        funded = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (funded) {
+    success("Faucet request submitted.");
+  } else {
+    warn("Automatic faucet request failed. Use your configured faucet or wallet UI to fund this address manually.");
+  }
+  console.log(`DID: ${did}`);
+  console.log(`Address: ${address}`);
+  console.log(`Faucet: ${config.network.faucetUrl}`);
+  return funded ? 0 : 1;
+}
+async function showAddress() {
+  const { address } = await loadWalletContext();
+  console.log(address);
+  return 0;
+}
+async function loadWalletContext() {
+  const config = loadMeshConfig();
+  const identity = await loadOrCreateKeypair(config.identity.dataDir);
+  const did = createDID(identity.publicKey);
+  const keypair = Ed25519Keypair.fromSecretKey(identity.secretKey);
+  return {
+    config,
+    did,
+    address: keypair.getPublicKey().toSuiAddress()
+  };
+}
+
+// src/commands/discover.ts
+async function handleDiscover(args) {
+  const capability = args[0]?.trim();
+  if (!capability) {
+    throw new Error("Usage: mesh discover <capability>");
+  }
+  const config = loadMeshConfig();
+  if (!config.network.packageId || !config.network.registryId) {
+    throw new Error("network.packageId and network.registryId must be configured before discovery.");
+  }
+  const registryClient = new RegistryClient(new MeshSuiClient2(config.network), config.network);
+  const agents = await registryClient.discoverByCapability(capability);
+  info(`Found ${agents.length} provider(s) for ${capability}`);
+  table(
+    ["Name", "DID", "Price (SUI)", "Endpoint"],
+    agents.map((agent) => {
+      const matched = agent.capabilities.find((entry) => entry.name.toLowerCase() === capability.toLowerCase());
+      return [
+        agent.name,
+        agent.did,
+        matched ? formatMistToSui(matched.pricing.amount) : "-",
+        agent.endpoint ?? "-"
+      ];
+    })
+  );
+  return 0;
+}
+
+// src/commands/dispute.ts
+import { readFile } from "fs/promises";
+import { DEFAULT_WALRUS_AGGREGATOR_URL, DEFAULT_WALRUS_PUBLISHER_URL, DisputeClient, MeshSuiClient as MeshSuiClient3, WalrusBlobStore, loadOrCreateKeypair as loadOrCreateKeypair2 } from "@hivemind-os/collective-core";
+import { DisputeStatus } from "@hivemind-os/collective-types";
+import { Ed25519Keypair as Ed25519Keypair2 } from "@mysten/sui/keypairs/ed25519";
+async function handleDispute(subcommand, args = [], deps = {}) {
+  switch (subcommand) {
+    case "open":
+      return await openDispute(args, deps);
+    case "respond":
+      return await respondToDispute(args, deps);
+    case "accept":
+      return await acceptResolution(args, deps);
+    case "status":
+      return await showStatus(args, deps);
+    default:
+      throw new Error("Usage: mesh dispute <open|respond|accept|status>");
+  }
+}
+async function openDispute(args, deps) {
+  const taskId = args[0];
+  if (!taskId) {
+    throw new Error("Usage: mesh dispute open <task-id> --split-mist <mist> (--evidence <text> | --evidence-file <path> | --evidence-blob-id <id>) [--arbitrator <address>]");
+  }
+  const proposedSplitMist = readMistFlag(args, "--split-mist");
+  const arbitratorAddress = readOptionalFlag(args, "--arbitrator");
+  const evidenceBlobId = await resolveEvidenceBlobId(args, deps);
+  const { client, keypair } = loadDisputeContext(deps);
+  const result = await client.openDispute({
+    taskId,
+    evidenceBlobId,
+    proposedSplitMist,
+    arbitratorAddress,
+    signer: keypair
+  });
+  success(`Opened dispute ${result.disputeId}`);
+  console.log(`Task ID: ${taskId}`);
+  console.log(`Evidence Blob: ${evidenceBlobId}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function respondToDispute(args, deps) {
+  const disputeId = args[0];
+  if (!disputeId) {
+    throw new Error("Usage: mesh dispute respond <dispute-id> --split-mist <mist> (--evidence <text> | --evidence-file <path> | --evidence-blob-id <id>)");
+  }
+  const proposedSplitMist = readMistFlag(args, "--split-mist");
+  const evidenceBlobId = await resolveEvidenceBlobId(args, deps);
+  const { client, keypair } = loadDisputeContext(deps);
+  const result = await client.respondToDispute({
+    disputeId,
+    evidenceBlobId,
+    proposedSplitMist,
+    signer: keypair
+  });
+  success(`Responded to dispute ${disputeId}`);
+  console.log(`Evidence Blob: ${evidenceBlobId}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function acceptResolution(args, deps) {
+  const disputeId = args[0];
+  const taskId = args[1];
+  if (!disputeId || !taskId) {
+    throw new Error("Usage: mesh dispute accept <dispute-id> <task-id>");
+  }
+  const { client, keypair } = loadDisputeContext(deps);
+  const result = await client.acceptResolution({ disputeId, taskId, signer: keypair });
+  success(`Resolved dispute ${disputeId}`);
+  console.log(`Requester Amount (SUI): ${formatMistToSui(result.requesterAmount)}`);
+  console.log(`Provider Amount (SUI): ${formatMistToSui(result.providerAmount)}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function showStatus(args, deps) {
+  const { client } = loadDisputeContext(deps);
+  if (args[0] === "--task") {
+    const taskId = readRequiredFlagValue(args, "--task");
+    const dispute2 = await client.getDisputeByTask(taskId);
+    if (!dispute2) {
+      throw new Error(`No dispute found for task ${taskId}.`);
+    }
+    return renderDisputeStatus(dispute2);
+  }
+  const disputeId = args[0]?.trim();
+  if (!disputeId) {
+    throw new Error("Usage: mesh dispute status <dispute-id> | mesh dispute status --task <task-id>");
+  }
+  const dispute = await client.getDispute(disputeId);
+  if (!dispute) {
+    throw new Error(`Dispute ${disputeId} was not found.`);
+  }
+  return renderDisputeStatus(dispute);
+}
+function renderDisputeStatus(dispute) {
+  info(`Dispute ${dispute.id}`);
+  table(
+    ["Field", "Value"],
+    [
+      ["Task", dispute.taskId],
+      ["Status", DisputeStatus[dispute.status] ?? "UNKNOWN"],
+      ["Requester", dispute.requester],
+      ["Provider", dispute.provider],
+      ["Escrow (SUI)", formatMistToSui(dispute.escrowAmount)],
+      ["Requester Proposal (SUI)", formatMistToSui(dispute.requesterProposedSplit)],
+      ["Provider Proposal (SUI)", formatMistToSui(dispute.providerProposedSplit)],
+      ["Evidence", dispute.requesterEvidenceBlob],
+      ["Counter Evidence", dispute.providerEvidenceBlob ?? "-"],
+      ["Arbitrator", dispute.arbitrator ?? "-"],
+      ["Opened", new Date(dispute.openedAt).toISOString()],
+      ["Resolved", dispute.resolvedAt ? new Date(dispute.resolvedAt).toISOString() : "-"]
+    ]
+  );
+  return 0;
+}
+function loadDisputeContext(deps) {
+  const config = (deps.loadConfig ?? loadMeshConfig)();
+  if (!config.network.packageId) {
+    throw new Error("network.packageId must be configured before disputing tasks.");
+  }
+  const identity = (deps.loadKeypair ?? loadOrCreateKeypair2)(config.identity.dataDir);
+  const keypair = Ed25519Keypair2.fromSecretKey(identity.secretKey);
+  const client = deps.createClient?.(config) ?? new DisputeClient(new MeshSuiClient3(config.network), config.network);
+  return { config, keypair, client };
+}
+async function resolveEvidenceBlobId(args, deps) {
+  const directBlobId = readOptionalFlag(args, "--evidence-blob-id");
+  const inlineEvidence = readOptionalFlag(args, "--evidence");
+  const filePath = readOptionalFlag(args, "--evidence-file");
+  const providedSources = [directBlobId, inlineEvidence, filePath].filter((value) => value !== void 0);
+  if (providedSources.length !== 1) {
+    throw new Error("Specify exactly one of --evidence, --evidence-file, or --evidence-blob-id.");
+  }
+  if (directBlobId) {
+    return directBlobId;
+  }
+  const readEvidenceFile = deps.readEvidenceFile ?? (async (path) => await readFile(path, "utf8"));
+  const contents = inlineEvidence ?? (filePath ? await readEvidenceFile(filePath) : void 0);
+  if (!contents) {
+    throw new Error("Evidence is required. Use --evidence, --evidence-file, or --evidence-blob-id.");
+  }
+  const blobStore = deps.createBlobStore?.() ?? new WalrusBlobStore({
+    publisherUrl: process.env.COLLECTIVE_WALRUS_PUBLISHER_URL ?? DEFAULT_WALRUS_PUBLISHER_URL,
+    aggregatorUrl: process.env.COLLECTIVE_WALRUS_AGGREGATOR_URL ?? DEFAULT_WALRUS_AGGREGATOR_URL
+  });
+  const stored = await blobStore.store(new TextEncoder().encode(contents));
+  return stored.blobId;
+}
+function readMistFlag(args, flag) {
+  const value = readOptionalFlag(args, flag);
+  if (!value || !/^\d+$/.test(value.trim())) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return BigInt(value.trim());
+}
+function readOptionalFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0) {
+    return void 0;
+  }
+  const value = args[index + 1]?.trim();
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}.`);
+  }
+  return value;
+}
+function readRequiredFlagValue(args, flag) {
+  const value = readOptionalFlag(args, flag);
+  if (!value) {
+    throw new Error(`Missing value for ${flag}.`);
+  }
+  return value;
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { createDID as createDID2, identityKeyExists, loadOrCreateKeypair as loadOrCreateKeypair3 } from "@hivemind-os/collective-core";
+import { Ed25519Keypair as Ed25519Keypair3 } from "@mysten/sui/keypairs/ed25519";
+async function handleInit(args) {
+  void args;
+  const dataDir = getMeshDataDir();
+  const configPath = getConfigPath();
+  const configExists = existsSync3(configPath);
+  const defaultConfig = buildDefaultConfig(dataDir);
+  const keyExists = await identityKeyExists(defaultConfig.identity.dataDir);
+  mkdirSync2(dataDir, { recursive: true });
+  mkdirSync2(defaultConfig.identity.dataDir, { recursive: true });
+  success(`Created data directory: ${displayPath(dataDir)}`);
+  const identity = await loadOrCreateKeypair3(defaultConfig.identity.dataDir);
+  const did = createDID2(identity.publicKey);
+  const address = Ed25519Keypair3.fromSecretKey(identity.secretKey).getPublicKey().toSuiAddress();
+  success(keyExists ? "Loaded identity key" : "Generated identity key");
+  console.log(`  DID: ${did}`);
+  console.log(`  Sui Address: ${address}`);
+  if (!configExists) {
+    saveMeshConfig(defaultConfig, configPath);
+  }
+  success(`${configExists ? "Using existing config" : "Created config"}: ${displayPath(configPath)}`);
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Fund your wallet: mesh wallet fund");
+  console.log("  2. Start the daemon: mesh daemon start");
+  console.log("  3. Configure your MCP app to use: mesh connect");
+  return 0;
+}
+function displayPath(value) {
+  const home = homedir2();
+  return value.startsWith(home) ? `~${value.slice(home.length)}` : value;
+}
+
+// src/commands/logs.ts
+import { createReadStream, existsSync as existsSync4, readFileSync as readFileSync4, watchFile } from "fs";
+async function handleLogs(args) {
+  const lines = Number.parseInt(readFlag(args, "--lines") ?? "50", 10);
+  const follow = args.includes("--follow");
+  const config = loadMeshConfig();
+  const logFile = config.daemon.logFile;
+  if (!logFile || !existsSync4(logFile)) {
+    throw new Error("Daemon log file does not exist yet. Start the daemon first.");
+  }
+  const contents = readFileSync4(logFile, "utf8");
+  const selected = contents.split(/\r?\n/).slice(-Math.max(1, lines)).join("\n").trim();
+  if (selected) {
+    console.log(selected);
+  }
+  if (!follow) {
+    return 0;
+  }
+  info(`Following ${logFile}`);
+  watchFile(logFile, { interval: 500 }, (current, previous) => {
+    if (current.size <= previous.size) {
+      return;
+    }
+    const stream = createReadStream(logFile, {
+      encoding: "utf8",
+      start: previous.size,
+      end: current.size
+    });
+    stream.on("data", (chunk) => {
+      process.stdout.write(chunk);
+    });
+  });
+  await new Promise(() => void 0);
+  return 0;
+}
+function readFlag(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+
+// src/commands/marketplace.ts
+import { readFile as readFile2 } from "fs/promises";
+import {
+  DEFAULT_WALRUS_AGGREGATOR_URL as DEFAULT_WALRUS_AGGREGATOR_URL2,
+  DEFAULT_WALRUS_PUBLISHER_URL as DEFAULT_WALRUS_PUBLISHER_URL2,
+  loadOrCreateKeypair as loadOrCreateKeypair4,
+  MarketplaceClient,
+  MeshSuiClient as MeshSuiClient4,
+  WalrusBlobStore as WalrusBlobStore2
+} from "@hivemind-os/collective-core";
+import { Ed25519Keypair as Ed25519Keypair4 } from "@mysten/sui/keypairs/ed25519";
+async function handleMarketplace(subcommand, args = [], deps = {}) {
+  switch (subcommand) {
+    case "post":
+      return await postMarketplaceTask(args, deps);
+    case "browse":
+      return await browseMarketplaceTasks(args, deps);
+    case "bid":
+      return await placeMarketplaceBid(args, deps);
+    case "accept-bid":
+      return await acceptMarketplaceBid(args, deps);
+    default:
+      throw new Error("Usage: mesh marketplace <post|browse|bid|accept-bid>");
+  }
+}
+async function postMarketplaceTask(args, deps) {
+  const capability = args[0];
+  if (!capability) {
+    throw new Error("Usage: mesh marketplace post <capability> --category <category> --price-mist <mist> (--input <text> | --input-file <path> | --input-blob-id <id>) [--agreement-hash <value>] [--dispute-window-ms <ms>] [--expiry-hours <hours>]");
+  }
+  const category = readRequiredFlag(args, "--category");
+  const priceMist = readMistFlag2(args, "--price-mist");
+  const inputBlobId = await resolveInputBlobId(args, deps);
+  const agreementHash = readOptionalFlag2(args, "--agreement-hash");
+  const disputeWindowMs = readOptionalInteger(args, "--dispute-window-ms") ?? 6e4;
+  const expiryHours = readOptionalInteger(args, "--expiry-hours") ?? 24;
+  const { client, keypair } = loadMarketplaceContext(deps);
+  const result = await client.postOpenTask({
+    capability,
+    category,
+    inputBlobId,
+    agreementHash,
+    priceMist,
+    disputeWindowMs,
+    expiryHours,
+    signer: keypair
+  });
+  success(`Posted marketplace task ${result.taskId}`);
+  console.log(`Category: ${category}`);
+  console.log(`Input Blob: ${inputBlobId}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function browseMarketplaceTasks(args, deps) {
+  const { client } = loadMarketplaceContext(deps);
+  const tasks = await client.browseOpenTasks({
+    category: readOptionalFlag2(args, "--category"),
+    minPriceMist: readOptionalMist(args, "--min-price-mist"),
+    maxPriceMist: readOptionalMist(args, "--max-price-mist"),
+    limit: readOptionalInteger(args, "--limit") ?? 20
+  });
+  info(`Found ${tasks.length} open marketplace task(s).`);
+  table(
+    ["Task", "Category", "Capability", "Price (MIST)", "Requester"],
+    tasks.map((task) => [task.id, task.category, task.capability, task.price.toString(), task.requester])
+  );
+  return 0;
+}
+async function placeMarketplaceBid(args, deps) {
+  const taskId = args[0];
+  if (!taskId) {
+    throw new Error("Usage: mesh marketplace bid <task-id> --price-mist <mist> [--reputation-score <score>] [--evidence <text>]");
+  }
+  const { client, keypair } = loadMarketplaceContext(deps);
+  const result = await client.placeBid({
+    taskId,
+    bidPriceMist: readMistFlag2(args, "--price-mist"),
+    reputationScore: readOptionalMist(args, "--reputation-score"),
+    evidenceBlob: readOptionalFlag2(args, "--evidence"),
+    signer: keypair
+  });
+  success(`Placed bid ${result.bidId}`);
+  console.log(`Task ID: ${taskId}`);
+  console.log(`Reputation Score: ${result.reputationScore.toString()}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function acceptMarketplaceBid(args, deps) {
+  const taskId = args[0];
+  const bidId = args[1];
+  if (!taskId || !bidId) {
+    throw new Error("Usage: mesh marketplace accept-bid <task-id> <bid-id> [--keep-other-bids]");
+  }
+  const { client, keypair } = loadMarketplaceContext(deps);
+  const result = await client.acceptBid({
+    taskId,
+    bidId,
+    rejectCompeting: !args.includes("--keep-other-bids"),
+    signer: keypair
+  });
+  success(`Accepted bid ${bidId}`);
+  console.log(`Rejected competing bids: ${result.rejectedBidIds.length}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+function loadMarketplaceContext(deps) {
+  const config = (deps.loadConfig ?? loadMeshConfig)();
+  if (!config.network.packageId) {
+    throw new Error("network.packageId must be configured before using marketplace commands.");
+  }
+  const identity = (deps.loadKeypair ?? loadOrCreateKeypair4)(config.identity.dataDir);
+  const keypair = Ed25519Keypair4.fromSecretKey(identity.secretKey);
+  const client = deps.createClient?.(config) ?? new MarketplaceClient(new MeshSuiClient4(config.network), config.network);
+  return { config, keypair, client };
+}
+async function resolveInputBlobId(args, deps) {
+  const directBlobId = readOptionalFlag2(args, "--input-blob-id");
+  const inlineInput = readOptionalFlag2(args, "--input");
+  const filePath = readOptionalFlag2(args, "--input-file");
+  const providedSources = [directBlobId, inlineInput, filePath].filter((value) => value !== void 0);
+  if (providedSources.length !== 1) {
+    throw new Error("Specify exactly one of --input, --input-file, or --input-blob-id.");
+  }
+  if (directBlobId) {
+    return directBlobId;
+  }
+  const readInputFile = deps.readInputFile ?? (async (path) => await readFile2(path, "utf8"));
+  const contents = inlineInput ?? (filePath ? await readInputFile(filePath) : void 0);
+  if (!contents) {
+    throw new Error("Task input is required. Use --input, --input-file, or --input-blob-id.");
+  }
+  const blobStore = deps.createBlobStore?.() ?? new WalrusBlobStore2({
+    publisherUrl: process.env.COLLECTIVE_WALRUS_PUBLISHER_URL ?? DEFAULT_WALRUS_PUBLISHER_URL2,
+    aggregatorUrl: process.env.COLLECTIVE_WALRUS_AGGREGATOR_URL ?? DEFAULT_WALRUS_AGGREGATOR_URL2
+  });
+  const stored = await blobStore.store(new TextEncoder().encode(contents));
+  return stored.blobId;
+}
+function readMistFlag2(args, flag) {
+  const value = readOptionalFlag2(args, flag);
+  if (!value || !/^\d+$/.test(value.trim())) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return BigInt(value.trim());
+}
+function readOptionalMist(args, flag) {
+  const value = readOptionalFlag2(args, flag);
+  if (!value) {
+    return void 0;
+  }
+  if (!/^\d+$/.test(value.trim())) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return BigInt(value.trim());
+}
+function readOptionalInteger(args, flag) {
+  const value = readOptionalFlag2(args, flag);
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return parsed;
+}
+function readRequiredFlag(args, flag) {
+  const value = readOptionalFlag2(args, flag);
+  if (!value) {
+    throw new Error(`Missing required ${flag}.`);
+  }
+  return value;
+}
+function readOptionalFlag2(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0) {
+    return void 0;
+  }
+  const value = args[index + 1]?.trim();
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}.`);
+  }
+  return value;
+}
+
+// src/commands/metering.ts
+import { loadConfig as loadDaemonConfig } from "@hivemind-os/collective-daemon/config";
+import { DaemonState } from "@hivemind-os/collective-daemon/state";
+import {
+  runMeshMeteredExecute,
+  runMeshVerifyResult
+} from "@hivemind-os/collective-mcp-server";
+import { MeshSuiClient as MeshSuiClient5, TaskClient } from "@hivemind-os/collective-core";
+import { PaymentScheme, TaskStatus } from "@hivemind-os/collective-types";
+async function handleMetering(subcommand, args = [], deps = {}) {
+  switch (subcommand) {
+    case "execute":
+      return await handleMeteringExecute(args, deps);
+    case "verify":
+      return await handleMeteringVerify(args, deps);
+    case "status":
+      return await handleMeteringStatus(args);
+    default:
+      throw new Error("Usage: mesh metering <execute|verify|status>");
+  }
+}
+async function handleMeteringExecute(args, deps) {
+  const capability = readRequiredFlag2(args, "--capability");
+  const input = readRequiredFlag2(args, "--input");
+  const maxPriceMist = readRequiredInteger(args, "--max-price-mist");
+  const unitPriceMist = readRequiredInteger(args, "--unit-price-mist");
+  const providerDid = readOptionalFlag3(args, "--provider-did");
+  const timeoutSeconds = readOptionalInteger2(args, "--timeout-seconds");
+  const config = deps.loadConfig?.() ?? loadDaemonConfig();
+  const state = await (deps.createState?.(config) ?? DaemonState.create(config));
+  try {
+    const result = await (deps.runMeteredExecute ?? runMeshMeteredExecute)({
+      capability,
+      input,
+      provider_did: providerDid,
+      max_price_mist: maxPriceMist,
+      unit_price_mist: unitPriceMist,
+      timeout_seconds: timeoutSeconds
+    }, toMeshToolContext(state));
+    success(`Metered task ${result.task_id}`);
+    table(
+      ["Field", "Value"],
+      [
+        ["Provider", result.provider_did],
+        ["Price (SUI)", formatMistToSui(BigInt(result.actual_price_mist))],
+        ["Max Price (SUI)", formatMistToSui(BigInt(result.max_price_mist))],
+        ["Unit Price (SUI)", formatMistToSui(BigInt(result.unit_price_mist))],
+        ["Units", result.metered_units.toString()],
+        ["Verified", result.verified ? "yes" : "no"]
+      ]
+    );
+    console.log(result.result);
+    return 0;
+  } finally {
+    await state.shutdown();
+  }
+}
+async function handleMeteringVerify(args, deps) {
+  const taskId = args[0]?.trim();
+  if (!taskId) {
+    throw new Error("Usage: mesh metering verify <task-id>");
+  }
+  const config = deps.loadConfig?.() ?? loadDaemonConfig();
+  const state = await (deps.createState?.(config) ?? DaemonState.create(config));
+  try {
+    const result = await (deps.runVerify ?? runMeshVerifyResult)({ task_id: taskId }, toMeshToolContext(state));
+    success(`Verification ${result.verified ? "passed" : "failed"} for ${result.task_id}`);
+    table(
+      ["Field", "Value"],
+      [
+        ["Verified", result.verified ? "yes" : "no"],
+        ["Units", result.metered_units.toString()],
+        ["Verification Hash", result.verification_hash ?? "-"]
+      ]
+    );
+    return result.verified ? 0 : 1;
+  } finally {
+    await state.shutdown();
+  }
+}
+async function handleMeteringStatus(args) {
+  const taskId = args[0]?.trim();
+  if (!taskId) {
+    throw new Error("Usage: mesh metering status <task-id>");
+  }
+  const config = loadMeshConfig();
+  const taskClient = new TaskClient(new MeshSuiClient5(config.network), config.network);
+  const task = await taskClient.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} was not found.`);
+  }
+  success(`Metered task ${task.id}`);
+  table(
+    ["Field", "Value"],
+    [
+      ["Status", TaskStatus[task.status] ?? "UNKNOWN"],
+      ["Scheme", task.paymentScheme ? PaymentScheme[task.paymentScheme] : "EXACT"],
+      ["Actual Price (SUI)", formatMistToSui(task.price)],
+      ["Max Price (SUI)", formatMistToSui(task.maxPrice ?? task.price)],
+      ["Unit Price (SUI)", formatMistToSui(task.unitPrice ?? 0n)],
+      ["Units", task.meteredUnits?.toString() ?? "0"],
+      ["Verification Hash", task.verificationHash ?? "-"],
+      ["Provider", task.provider ?? "-"]
+    ]
+  );
+  return 0;
+}
+function toMeshToolContext(state) {
+  return {
+    did: state.did,
+    keypair: state.keypair,
+    suiClient: state.suiClient,
+    registryClient: state.registryClient,
+    taskClient: state.taskClient,
+    agentCache: state.agentCache,
+    blobStore: state.blobStore,
+    spendingPolicy: state.spendingPolicy,
+    networkConfig: state.network,
+    relayAuthProvider: state.relayAuthProvider,
+    x402Client: state.x402Client
+  };
+}
+function readRequiredFlag2(args, flag) {
+  const value = readOptionalFlag3(args, flag);
+  if (!value) {
+    throw new Error("Usage: mesh metering execute --capability <cap> --input <text> --max-price-mist <mist> --unit-price-mist <mist> [--provider-did <did>] [--timeout-seconds <seconds>]");
+  }
+  return value;
+}
+function readRequiredInteger(args, flag) {
+  const value = readOptionalInteger2(args, flag);
+  if (value === void 0) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return value;
+}
+function readOptionalInteger2(args, flag) {
+  const value = readOptionalFlag3(args, flag);
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return parsed;
+}
+function readOptionalFlag3(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0) {
+    return void 0;
+  }
+  const value = args[index + 1]?.trim();
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}.`);
+  }
+  return value;
+}
+
+// src/commands/multi-execute.ts
+import { loadConfig as loadDaemonConfig2 } from "@hivemind-os/collective-daemon/config";
+import { DaemonState as DaemonState2 } from "@hivemind-os/collective-daemon/state";
+import {
+  runMeshMultiExecute
+} from "@hivemind-os/collective-mcp-server";
+import { AggregationMode, ProviderSelectionStrategy } from "@hivemind-os/collective-types";
+async function handleMultiExecute(args = [], deps = {}) {
+  const capability = readRequiredFlag3(args, "--capability");
+  const input = parseJsonInput(readRequiredFlag3(args, "--input"));
+  const fanOutCount = readOptionalInteger3(args, "--fan-out");
+  const strategy = readOptionalStrategy(args, "--strategy");
+  const aggregation = readOptionalAggregation(args, "--aggregation");
+  const maxPricePerProvider = readOptionalInteger3(args, "--max-price-per-provider");
+  const timeout = readOptionalInteger3(args, "--timeout");
+  const config = deps.loadConfig?.() ?? loadDaemonConfig2();
+  const state = await (deps.createState?.(config) ?? DaemonState2.create(config));
+  try {
+    const result = await (deps.runMultiExecute ?? runMeshMultiExecute)({
+      capability,
+      input,
+      fanOutCount,
+      strategy,
+      aggregation,
+      maxPricePerProvider,
+      timeout
+    }, toMeshToolContext2(state));
+    info(`Selected ${result.providers.length} provider(s) for ${result.capability}.`);
+    table(
+      ["Provider", "Price (MIST)", "Reputation", "Latency (ms)"],
+      result.providers.map((provider) => [
+        provider.did,
+        provider.price_mist,
+        provider.reputation.toFixed(2),
+        provider.estimated_latency_ms?.toString() ?? "-"
+      ])
+    );
+    table(
+      ["Provider", "Status", "Duration (ms)", "Summary"],
+      result.results.map((entry) => [
+        entry.provider,
+        entry.status,
+        entry.duration_ms.toString(),
+        entry.error ?? summarizeValue(entry.result)
+      ])
+    );
+    success(`Total cost: ${result.total_cost_mist} MIST`);
+    if (result.aggregated_result !== void 0) {
+      console.log(JSON.stringify(result.aggregated_result, null, 2));
+    }
+    return 0;
+  } finally {
+    await state.shutdown();
+  }
+}
+function toMeshToolContext2(state) {
+  return {
+    did: state.did,
+    keypair: state.keypair,
+    suiClient: state.suiClient,
+    registryClient: state.registryClient,
+    taskClient: state.taskClient,
+    agentCache: state.agentCache,
+    blobStore: state.blobStore,
+    spendingPolicy: state.spendingPolicy,
+    networkConfig: state.network,
+    relayAuthProvider: state.relayAuthProvider,
+    x402Client: state.x402Client
+  };
+}
+function summarizeValue(value) {
+  if (value === void 0) {
+    return "-";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function parseJsonInput(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error("Invalid --input JSON.");
+  }
+}
+function readOptionalStrategy(args, flag) {
+  const value = readOptionalFlag4(args, flag);
+  if (!value) {
+    return void 0;
+  }
+  if (Object.values(ProviderSelectionStrategy).includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid ${flag}.`);
+}
+function readOptionalAggregation(args, flag) {
+  const value = readOptionalFlag4(args, flag);
+  if (!value) {
+    return void 0;
+  }
+  if (Object.values(AggregationMode).includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid ${flag}.`);
+}
+function readOptionalInteger3(args, flag) {
+  const value = readOptionalFlag4(args, flag);
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new Error(`Missing or invalid ${flag}.`);
+  }
+  return parsed;
+}
+function readRequiredFlag3(args, flag) {
+  const value = readOptionalFlag4(args, flag);
+  if (!value) {
+    throw new Error("Usage: mesh multi-execute --capability <cap> --input <json> [--fan-out <n>] [--strategy <strategy>] [--aggregation <mode>] [--max-price-per-provider <mist>] [--timeout <ms>]");
+  }
+  return value;
+}
+function readOptionalFlag4(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0) {
+    return void 0;
+  }
+  const value = args[index + 1]?.trim();
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}.`);
+  }
+  return value;
+}
+
+// src/commands/policy.ts
+import { PaymentRail as PaymentRail2 } from "@hivemind-os/collective-types";
+async function handlePolicy(subcommand, args = []) {
+  if (subcommand !== "set") {
+    throw new Error("Usage: mesh policy set [--daily <amount_sui>] [--per-task <amount_sui>]");
+  }
+  const daily = readFlag2(args, "--daily");
+  const perTask = readFlag2(args, "--per-task");
+  if (!daily && !perTask) {
+    throw new Error("Provide at least one policy flag: --daily or --per-task");
+  }
+  const config = loadMeshConfig();
+  if (daily) {
+    upsertLimit(config, "day", parseSuiToMist(daily));
+  }
+  if (perTask) {
+    upsertLimit(config, "transaction", parseSuiToMist(perTask));
+  }
+  saveMeshConfig(config);
+  success("Updated spending policy.");
+  return 0;
+}
+function upsertLimit(config, interval, amount) {
+  const existing = config.spending.limits.find((limit) => limit.interval === interval);
+  if (existing) {
+    existing.amount = amount;
+    existing.rail = PaymentRail2.SUI_ESCROW;
+    return;
+  }
+  config.spending.limits.push({
+    amount,
+    interval,
+    rail: PaymentRail2.SUI_ESCROW
+  });
+}
+function readFlag2(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+
+// src/commands/register.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve4 } from "path";
+import { createDID as createDID3, ed25519ToX25519, loadOrCreateKeypair as loadOrCreateKeypair5, MeshSuiClient as MeshSuiClient6, RegistryClient as RegistryClient2 } from "@hivemind-os/collective-core";
+import { PaymentRail as PaymentRail3 } from "@hivemind-os/collective-types";
+import { Ed25519Keypair as Ed25519Keypair5 } from "@mysten/sui/keypairs/ed25519";
+import yaml2 from "js-yaml";
+async function handleRegister(args) {
+  const definition = loadProviderDefinition(args);
+  const config = loadMeshConfig();
+  assertNetworkConfigured(config.network);
+  const identity = await loadOrCreateKeypair5(config.identity.dataDir);
+  const did = createDID3(identity.publicKey);
+  const keypair = Ed25519Keypair5.fromSecretKey(identity.secretKey);
+  const encryptionKeyPair = ed25519ToX25519(identity.secretKey);
+  const suiClient = new MeshSuiClient6(config.network);
+  const registryClient = new RegistryClient2(suiClient, config.network);
+  const result = await registryClient.registerAgent({
+    name: definition.name,
+    did,
+    description: definition.description,
+    capabilities: definition.capabilities,
+    endpoint: `mesh://agent/${did}`,
+    encryptionPublicKey: encryptionKeyPair.publicKey,
+    keypair
+  });
+  success("Provider registered on Agentic Mesh.");
+  console.log(`Agent Card ID: ${result.agentCardId}`);
+  console.log(`DID: ${did}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+function loadProviderDefinition(args) {
+  const configFlagIndex = args.indexOf("--config");
+  if (configFlagIndex >= 0) {
+    const configPath = args[configFlagIndex + 1];
+    if (!configPath) {
+      throw new Error("Usage: mesh register --config <path>");
+    }
+    return parseProviderConfigFile(resolve4(configPath));
+  }
+  const name = readFlag3(args, "--name");
+  const description = readFlag3(args, "--description") ?? `${name ?? "Agent"} provider`;
+  const capabilityFlags = readFlags(args, "--capability");
+  if (!name || capabilityFlags.length === 0) {
+    throw new Error('Usage: mesh register --name <name> --capability "name:description:version:price_mist"');
+  }
+  return {
+    name,
+    description,
+    capabilities: capabilityFlags.map(parseInlineCapability)
+  };
+}
+function parseProviderConfigFile(path) {
+  const loaded = yaml2.load(readFileSync5(path, "utf8"));
+  if (!loaded || typeof loaded !== "object" || Array.isArray(loaded)) {
+    throw new Error(`Invalid provider config: ${path}`);
+  }
+  const record = loaded;
+  const name = asString(record.name);
+  const description = asString(record.description) ?? `${name ?? "Agent"} provider`;
+  const capabilitiesRaw = Array.isArray(record.capabilities) ? record.capabilities : [];
+  const capabilities = capabilitiesRaw.map((entry, index) => parseCapabilityRecord(entry, index));
+  if (!name || capabilities.length === 0) {
+    throw new Error("Provider config must include name and at least one capability.");
+  }
+  return { name, description, capabilities };
+}
+function parseCapabilityRecord(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`capabilities[${index}] must be an object.`);
+  }
+  const record = value;
+  const pricing = record.pricing && typeof record.pricing === "object" && !Array.isArray(record.pricing) ? record.pricing : void 0;
+  const amount = pricing?.amount ?? record.priceMist ?? record.price_mist ?? record.price;
+  const name = asString(record.name);
+  const description = asString(record.description);
+  const version = asString(record.version);
+  if (!name || !description || !version || amount === void 0) {
+    throw new Error(`capabilities[${index}] is missing required fields.`);
+  }
+  return buildCapability(name, description, version, amount);
+}
+function parseInlineCapability(value) {
+  const parts = value.split(":");
+  if (parts.length < 4) {
+    throw new Error(`Invalid capability format: ${value}`);
+  }
+  const [name, description, version, ...priceParts] = parts;
+  return buildCapability(name, description, version, priceParts.join(":"));
+}
+function buildCapability(name, description, version, amount) {
+  return {
+    name,
+    description,
+    version,
+    pricing: {
+      rail: PaymentRail3.SUI_ESCROW,
+      amount: parseMistAmount(amount),
+      currency: "MIST"
+    }
+  };
+}
+function parseMistAmount(value) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return BigInt(Math.floor(value));
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error(`Invalid MIST amount: ${String(value)}`);
+}
+function readFlag3(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function readFlags(args, flag) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === flag && args[index + 1]) {
+      values.push(args[index + 1]);
+    }
+  }
+  return values;
+}
+function assertNetworkConfigured(network) {
+  if (!network.packageId || !network.registryId) {
+    throw new Error("network.packageId and network.registryId must be configured before registering.");
+  }
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+// src/commands/relay-registry.ts
+import { loadOrCreateKeypair as loadOrCreateKeypair6, MeshSuiClient as MeshSuiClient7, RelayRegistryClient } from "@hivemind-os/collective-core";
+import { Ed25519Keypair as Ed25519Keypair6 } from "@mysten/sui/keypairs/ed25519";
+async function handleRelayRegistry(subcommand, args = [], deps = {}) {
+  switch (subcommand) {
+    case "register":
+      return await registerRelay(args, deps);
+    case "list":
+      return await listRelays(deps);
+    case "heartbeat":
+      return await heartbeatRelay(args, deps);
+    case "deactivate":
+      return await deactivateRelay(args, deps);
+    default:
+      throw new Error("Usage: mesh relay <register|list|heartbeat|deactivate>");
+  }
+}
+async function registerRelay(args, deps) {
+  const endpoint = readRequiredFlag4(args, "--endpoint");
+  const stakeId = readRequiredFlag4(args, "--stake-id");
+  const region = readRequiredFlag4(args, "--region");
+  const fee = Number(readRequiredFlag4(args, "--fee"));
+  if (!Number.isInteger(fee) || fee < 0 || fee > 1e4) {
+    throw new Error("Usage: mesh relay register --endpoint <url> --stake-id <id> --region <region> --fee <bps> [--capabilities a,b]");
+  }
+  const capabilities = readCapabilities(args);
+  const { client, keypair } = loadRelayContext(deps);
+  const result = await client.registerRelay({
+    endpoint,
+    stakeId,
+    region,
+    routingFeeBps: fee,
+    capabilities,
+    signer: keypair
+  });
+  success("Relay registered.");
+  console.log(`Relay ID: ${result.relayId}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  console.log(`Capabilities: ${capabilities.join(", ")}`);
+  return 0;
+}
+async function listRelays(deps) {
+  const { client } = loadRelayContext(deps);
+  const relays = await client.listRelays();
+  info(`Found ${relays.length} active relay(s).`);
+  table(
+    ["Relay ID", "Region", "Fee (bps)", "Stake (SUI)", "Routed", "Fees Earned (SUI)", "Endpoint"],
+    relays.map((relay) => summarizeRelay(relay))
+  );
+  return 0;
+}
+async function heartbeatRelay(args, deps) {
+  const relayId = readRequiredFlag4(args, "--relay-id");
+  const { client, keypair } = loadRelayContext(deps);
+  const result = await client.heartbeat({ relayId, signer: keypair });
+  success("Relay heartbeat submitted.");
+  console.log(`Last Heartbeat: ${new Date(result.lastHeartbeat).toISOString()}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function deactivateRelay(args, deps) {
+  const relayId = readRequiredFlag4(args, "--relay-id");
+  const { client, keypair } = loadRelayContext(deps);
+  const result = await client.deactivateRelay({ relayId, signer: keypair });
+  success("Relay deactivated.");
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+function loadRelayContext(deps) {
+  const config = (deps.loadConfig ?? loadMeshConfig)();
+  if (!config.network.packageId) {
+    throw new Error("network.packageId must be configured before using relay registry commands.");
+  }
+  const identity = (deps.loadKeypair ?? loadOrCreateKeypair6)(config.identity.dataDir);
+  const keypair = Ed25519Keypair6.fromSecretKey(identity.secretKey);
+  const client = deps.createClient?.(config) ?? new RelayRegistryClient(new MeshSuiClient7(config.network), config.network);
+  return { config, keypair, client };
+}
+function readRequiredFlag4(args, flag) {
+  const index = args.indexOf(flag);
+  const value = index >= 0 ? args[index + 1]?.trim() : "";
+  if (!value) {
+    throw new Error(`Missing required flag ${flag}.`);
+  }
+  return value;
+}
+function readCapabilities(args) {
+  const index = args.indexOf("--capabilities");
+  const value = index >= 0 ? args[index + 1] : void 0;
+  if (!value) {
+    return ["routing"];
+  }
+  const parsed = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return parsed.length > 0 ? parsed : ["routing"];
+}
+function summarizeRelay(relay) {
+  return [
+    relay.id,
+    relay.region,
+    relay.routingFeeBps.toString(),
+    relay.stakeAmountMist !== void 0 ? formatMistToSui(relay.stakeAmountMist) : "-",
+    relay.totalRouted.toString(),
+    formatMistToSui(relay.totalFeesEarnedMist),
+    relay.endpoint
+  ];
+}
+
+// src/commands/stake.ts
+import { loadOrCreateKeypair as loadOrCreateKeypair7, MeshSuiClient as MeshSuiClient8, StakingClient, STAKING_COOLDOWN_MS } from "@hivemind-os/collective-core";
+import { Ed25519Keypair as Ed25519Keypair7 } from "@mysten/sui/keypairs/ed25519";
+async function handleStake(subcommand, args = [], deps = {}) {
+  switch (subcommand) {
+    case "deposit":
+      return await depositStake(args, deps);
+    case "status":
+      return await showStakeStatus(deps);
+    case "withdraw":
+      return await withdrawStake(args, deps);
+    default:
+      throw new Error("Usage: mesh stake <deposit|status|withdraw>");
+  }
+}
+async function depositStake(args, deps) {
+  const amount = args[0];
+  if (!amount) {
+    throw new Error("Usage: mesh stake deposit <amount-sui> [--type agent|relay]");
+  }
+  const stakeType = readStakeType(args.slice(1));
+  const amountMist = parseSuiToMist(amount);
+  const { client, keypair } = loadStakeContext(deps);
+  const result = await client.depositStake({ amountMist, stakeType, signer: keypair });
+  success(`Deposited ${amount} SUI as ${stakeType} stake.`);
+  console.log(`Stake ID: ${result.stakeId}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+async function showStakeStatus(deps) {
+  const { client, keypair } = loadStakeContext(deps);
+  const owner = keypair.getPublicKey().toSuiAddress();
+  const stake = await client.getStakeByOwner(owner);
+  if (!stake) {
+    info("No stake position found for this wallet.");
+    return 0;
+  }
+  const cooldownEndsAt = stake.deactivatedAt > 0 ? stake.deactivatedAt + STAKING_COOLDOWN_MS : 0;
+  success(`Stake position ${stake.id}`);
+  table(
+    ["Field", "Value"],
+    [
+      ["Owner", stake.owner],
+      ["Type", stake.stakeType],
+      ["Balance (SUI)", formatMistToSui(stake.balanceMist)],
+      ["Balance (MIST)", stake.balanceMist.toString()],
+      ["Active", String(stake.isActive ?? false)],
+      ["Meets Minimum", String(stake.meetsMinium ?? false)],
+      ["Slashed (SUI)", formatMistToSui(stake.slashedAmount)],
+      ["Staked At", new Date(stake.stakedAt).toISOString()],
+      ["Deactivated At", stake.deactivatedAt > 0 ? new Date(stake.deactivatedAt).toISOString() : "-"],
+      ["Cooldown Ends", cooldownEndsAt > 0 ? new Date(cooldownEndsAt).toISOString() : "-"]
+    ]
+  );
+  return 0;
+}
+async function withdrawStake(args, deps) {
+  void args;
+  const { client, keypair } = loadStakeContext(deps);
+  const owner = keypair.getPublicKey().toSuiAddress();
+  const stake = await client.getStakeByOwner(owner);
+  if (!stake) {
+    throw new Error("No stake position found for this wallet.");
+  }
+  if (stake.deactivatedAt === 0) {
+    const result2 = await client.startDeactivation({ stakeId: stake.id, signer: keypair });
+    info("Stake deactivation started.");
+    console.log(`Cooldown ends: ${new Date(result2.cooldownEndsAt).toISOString()}`);
+    console.log(`Tx Digest: ${result2.txDigest}`);
+    return 0;
+  }
+  const cooldownEndsAt = stake.deactivatedAt + STAKING_COOLDOWN_MS;
+  if (Date.now() < cooldownEndsAt) {
+    warn(`Cooldown still active until ${new Date(cooldownEndsAt).toISOString()}.`);
+    return 1;
+  }
+  const result = await client.withdrawStake({ stakeId: stake.id, signer: keypair });
+  success("Stake withdrawn.");
+  console.log(`Returned (SUI): ${formatMistToSui(result.amountReturned)}`);
+  console.log(`Returned (MIST): ${result.amountReturned.toString()}`);
+  console.log(`Tx Digest: ${result.txDigest}`);
+  return 0;
+}
+function loadStakeContext(deps) {
+  const config = (deps.loadConfig ?? loadMeshConfig)();
+  if (!config.network.packageId) {
+    throw new Error("network.packageId must be configured before staking.");
+  }
+  const identity = (deps.loadKeypair ?? loadOrCreateKeypair7)(config.identity.dataDir);
+  const keypair = Ed25519Keypair7.fromSecretKey(identity.secretKey);
+  const client = deps.createClient?.(config) ?? new StakingClient(new MeshSuiClient8(config.network), config.network);
+  return { config, keypair, client };
+}
+function readStakeType(args) {
+  const typeFlagIndex = args.indexOf("--type");
+  if (typeFlagIndex >= 0) {
+    const value = args[typeFlagIndex + 1]?.trim().toLowerCase();
+    if (value === "agent" || value === "relay") {
+      return value;
+    }
+    throw new Error("Usage: mesh stake deposit <amount-sui> [--type agent|relay]");
+  }
+  return "agent";
+}
+
+// src/commands/task.ts
+import { MeshSuiClient as MeshSuiClient9, TaskClient as TaskClient2 } from "@hivemind-os/collective-core";
+import { TaskStatus as TaskStatus2 } from "@hivemind-os/collective-types";
+async function handleTask(subcommand, args = []) {
+  if (subcommand !== "status") {
+    throw new Error("Usage: mesh task status <id>");
+  }
+  const taskId = args[0];
+  if (!taskId) {
+    throw new Error("Usage: mesh task status <id>");
+  }
+  const config = loadMeshConfig();
+  const taskClient = new TaskClient2(new MeshSuiClient9(config.network), config.network);
+  const task = await taskClient.getTask(taskId);
+  if (!task) {
+    throw new Error(`Task ${taskId} was not found.`);
+  }
+  success(`Task ${task.id}`);
+  table(
+    ["Field", "Value"],
+    [
+      ["Status", TaskStatus2[task.status] ?? "UNKNOWN"],
+      ["Capability", task.capability],
+      ["Category", task.category],
+      ["Price (SUI)", formatMistToSui(task.price)],
+      ["Requester", task.requester],
+      ["Provider", task.provider ?? "-"],
+      ["Result Blob", task.resultBlobId ?? "-"],
+      ["Created", new Date(task.createdAt).toISOString()],
+      ["Expires", new Date(task.expiresAt).toISOString()]
+    ]
+  );
+  return 0;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+async function runCli(args = process.argv.slice(2)) {
+  const command = args[0];
+  const subcommand = args[1];
+  switch (command) {
+    case "init":
+      return await handleInit(args.slice(1));
+    case "connect":
+      return await handleConnect(args.slice(1));
+    case "daemon":
+      return await handleDaemon(subcommand, args.slice(2));
+    case "auth":
+      return await handleAuth(subcommand, args.slice(2));
+    case "register":
+      return await handleRegister(args.slice(1));
+    case "config":
+      return await handleConfig(args.slice(1));
+    case "analytics":
+      return await handleAnalytics(subcommand, args.slice(2));
+    case "policy":
+      return await handlePolicy(subcommand, args.slice(2));
+    case "wallet":
+      return await handleWallet(subcommand, args.slice(2));
+    case "discover":
+      return await handleDiscover(args.slice(1));
+    case "dispute":
+      return await handleDispute(subcommand, args.slice(2));
+    case "stake":
+      return await handleStake(subcommand, args.slice(2));
+    case "relay":
+      return await handleRelayRegistry(subcommand, args.slice(2));
+    case "task":
+      return await handleTask(subcommand, args.slice(2));
+    case "logs":
+      return await handleLogs(args.slice(1));
+    case "marketplace":
+      return await handleMarketplace(subcommand, args.slice(2));
+    case "metering":
+      return await handleMetering(subcommand, args.slice(2));
+    case "multi-execute":
+      return await handleMultiExecute(args.slice(1));
+    case "--help":
+    case "-h":
+    case "help":
+      printHelp();
+      return 0;
+    case "--version":
+    case "-v":
+      printVersion();
+      return 0;
+    default:
+      printHelp();
+      return command ? 1 : 0;
+  }
+}
+function printHelp() {
+  console.log(`Agentic Mesh CLI
+
+Usage:
+  mesh <command> [options]
+
+Commands:
+  init                 First-time setup for your local mesh identity
+  connect              Start the MCP shim bridge
+  daemon <cmd>         Manage the background daemon (start|stop|status)
+  auth <cmd>           Inspect or refresh daemon auth (status|reauth)
+  register             Register this node as a provider
+  config [subcmd]      Show or update config values
+  analytics <cmd>      Query indexer analytics (summary|top-providers|task-volume)
+  policy set           Update spending limits
+  wallet <cmd>         Wallet tools (balance|fund|address)
+  discover <cap>       Find providers for a capability
+  dispute <cmd>        Manage disputes (open|respond|accept|status)
+  marketplace <cmd>    Marketplace tools (post|browse|bid|accept-bid)
+  metering <cmd>       Metered task tools (execute|verify|status)
+  multi-execute        Execute across multiple providers
+  stake <cmd>          Manage staking (deposit|status|withdraw)
+  relay <cmd>          Manage community relays (register|list|heartbeat|deactivate)
+  task status <id>     Inspect a task on Sui
+  logs [--follow]      Show daemon logs
+  help                 Show this help text
+  --version            Print the CLI version`);
+}
+function printVersion() {
+  console.log(VERSION);
+}
+async function main() {
+  const exitCode = await runCli();
+  process.exit(exitCode);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((caught) => {
+    const message = caught instanceof Error ? caught.message : String(caught);
+    error(message);
+    if (isAuthError(caught)) {
+      info('Run "mesh auth status" to inspect the session or "mesh auth reauth" to open the daemon portal.');
+    }
+    process.exit(1);
+  });
+}
+function isAuthError(errorToCheck) {
+  if (errorToCheck instanceof SessionExpiredError) {
+    return true;
+  }
+  return errorToCheck instanceof Error && /authentication expired|re-authenticate via the daemon portal/i.test(errorToCheck.message);
+}
+export {
+  printHelp,
+  printVersion,
+  runCli
+};
+//# sourceMappingURL=index.js.map