@g0hub/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,3406 @@
+#!/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/lib/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  banner: () => banner,
+  c: () => c,
+  coolGradient: () => coolGradient,
+  createTable: () => createTable,
+  formatDate: () => formatDate,
+  formatPrice: () => formatPrice,
+  formatRating: () => formatRating,
+  formatRepScore: () => formatRepScore,
+  formatStatus: () => formatStatus,
+  g0Gradient: () => g0Gradient,
+  infoBox: () => infoBox,
+  section: () => section,
+  showError: () => showError,
+  showMotd: () => showMotd,
+  showSuccess: () => showSuccess,
+  spin: () => spin
+});
+import chalk from "chalk";
+import gradient from "gradient-string";
+import figlet from "figlet";
+import ora from "ora";
+import Table from "cli-table3";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function banner() {
+  const art = figlet.textSync("g0", {
+    font: "ANSI Shadow",
+    horizontalLayout: "fitted"
+  });
+  console.log(g0Gradient.multiline(art));
+  console.log(
+    c.muted("  AI Agent Marketplace") + c.dim(" \u2014 ") + c.warm("hire agents, get things done")
+  );
+  showMotd().catch(() => {
+  });
+  console.log();
+}
+function ensureCacheDir() {
+  if (!existsSync(BANNER_CACHE_DIR)) {
+    mkdirSync(BANNER_CACHE_DIR, { recursive: true });
+  }
+}
+function readBannerCache() {
+  try {
+    if (existsSync(BANNER_CACHE_FILE)) {
+      const data = JSON.parse(readFileSync(BANNER_CACHE_FILE, "utf-8"));
+      if (Date.now() - data.fetchedAt < BANNER_CACHE_TTL) return data;
+    }
+  } catch {
+  }
+  return null;
+}
+function writeBannerCache(data) {
+  try {
+    ensureCacheDir();
+    writeFileSync(BANNER_CACHE_FILE, JSON.stringify(data));
+  } catch {
+  }
+}
+function renderBannerLine(data) {
+  const icon = data.style === "promo" ? "\u2728" : data.style === "update" ? "\u{1F680}" : data.style === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+  const color = data.style === "promo" ? c.pink : data.style === "update" ? c.cool : data.style === "warning" ? c.warn : c.muted;
+  let line = `  ${icon} ${color(data.content)}`;
+  if (data.url) line += c.dim(`  \u2192 ${data.url}`);
+  return line;
+}
+async function fetchBannerRemote(cached) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), BANNER_FETCH_TIMEOUT);
+    const headers = { "User-Agent": "@g0hub/cli/1.0.0" };
+    if (cached?.etag) headers["If-None-Match"] = cached.etag;
+    const res = await fetch(BANNER_API_URL, { signal: controller.signal, headers });
+    clearTimeout(timer);
+    if (res.status === 304 && cached) {
+      const refreshed = { ...cached, fetchedAt: Date.now() };
+      writeBannerCache(refreshed);
+      return refreshed;
+    }
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (!body.content) return null;
+    const banner2 = {
+      content: body.content,
+      style: body.style || "info",
+      url: body.url,
+      fetchedAt: Date.now(),
+      etag: res.headers.get("etag") || void 0
+    };
+    writeBannerCache(banner2);
+    return banner2;
+  } catch {
+    return null;
+  }
+}
+async function showMotd() {
+  const cached = readBannerCache();
+  if (cached) {
+    console.log(renderBannerLine(cached));
+  }
+  fetchBannerRemote(cached).then((fresh) => {
+    if (!cached && fresh) {
+      console.log(renderBannerLine(fresh));
+    }
+  }).catch(() => {
+  });
+}
+function spin(text) {
+  return ora({ text, color: "yellow", spinner: "dots12" }).start();
+}
+function createTable(head, colWidths) {
+  return new Table({
+    head: head.map((h) => c.warm.bold(h)),
+    ...colWidths ? { colWidths } : {},
+    chars: {
+      top: "\u2500",
+      "top-mid": "\u252C",
+      "top-left": "\u250C",
+      "top-right": "\u2510",
+      bottom: "\u2500",
+      "bottom-mid": "\u2534",
+      "bottom-left": "\u2514",
+      "bottom-right": "\u2518",
+      left: "\u2502",
+      "left-mid": "\u251C",
+      mid: "\u2500",
+      "mid-mid": "\u253C",
+      right: "\u2502",
+      "right-mid": "\u2524",
+      middle: "\u2502"
+    },
+    style: {
+      head: [],
+      border: ["gray"],
+      compact: false
+    }
+  });
+}
+function formatPrice(price, currency = "USDC") {
+  const n = typeof price === "string" ? parseFloat(price) : price;
+  return c.bold(`$${n.toFixed(n % 1 === 0 ? 0 : 2)} ${c.dim(currency)}`);
+}
+function formatRating(rating, count) {
+  const stars = "\u2605".repeat(Math.round(rating)) + "\u2606".repeat(5 - Math.round(rating));
+  const color = rating >= 4 ? c.warm : rating >= 3 ? c.warn : c.muted;
+  return color(stars + ` ${rating.toFixed(1)}`) + (count !== void 0 ? c.dim(` (${count})`) : "");
+}
+function formatRepScore(score) {
+  if (score == null) return c.muted("\u2014");
+  if (score >= 90) return chalk.bgHex("#00E676").hex("#000").bold(` ${score} `);
+  if (score >= 75) return chalk.bgHex("#4CC9F0").hex("#000").bold(` ${score} `);
+  if (score >= 50) return chalk.bgHex("#FFB300").hex("#000").bold(` ${score} `);
+  return chalk.bgGray.white.bold(` ${score} `);
+}
+function formatStatus(status) {
+  const s = status.toUpperCase();
+  switch (s) {
+    case "ACTIVE":
+      return c.success.bold("\u25CF ACTIVE");
+    case "BUSY":
+      return c.warn.bold("\u25CF BUSY");
+    case "COMPLETED":
+      return c.success("\u2713 COMPLETED");
+    case "EXECUTING":
+      return c.cool("\u27F3 EXECUTING");
+    case "CREATED":
+    case "MATCHING":
+      return c.warn("\u25CC " + s);
+    case "DELIVERED":
+      return c.cool("\u{1F4E6} DELIVERED");
+    case "DISPUTED":
+      return c.err.bold("\u26A1 DISPUTED");
+    case "PENDING":
+    case "PENDING_VERIFICATION":
+      return c.warn("\u25CC PENDING");
+    case "OFFLINE":
+      return c.muted("\u25CF OFFLINE");
+    case "FAILED":
+    case "CANCELLED":
+      return c.err("\u2717 " + s);
+    default:
+      return c.muted(s);
+  }
+}
+function formatDate(dateStr) {
+  const d = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - d.getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return c.muted("just now");
+  if (mins < 60) return c.muted(`${mins}m ago`);
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return c.muted(`${hrs}h ago`);
+  const days = Math.floor(hrs / 24);
+  if (days < 7) return c.muted(`${days}d ago`);
+  return c.muted(
+    d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" })
+  );
+}
+function infoBox(title, lines) {
+  const width = 60;
+  const border = c.muted("\u2502");
+  console.log(c.muted("\u250C" + "\u2500".repeat(width) + "\u2510"));
+  console.log(border + " " + c.warm.bold(title).padEnd(width + 9) + border);
+  console.log(c.muted("\u251C" + "\u2500".repeat(width) + "\u2524"));
+  for (const line of lines) {
+    const stripped = line.replace(/\x1B\[\d+m/g, "");
+    const pad = width - stripped.length;
+    console.log(border + " " + line + " ".repeat(Math.max(0, pad)) + border);
+  }
+  console.log(c.muted("\u2514" + "\u2500".repeat(width) + "\u2518"));
+}
+function showError(err) {
+  if (err instanceof Error) {
+    console.error(c.err.bold("\n  \u2717 Error: ") + chalk.white(err.message));
+    if ("status" in err) {
+      console.error(c.muted(`    HTTP ${err.status}`));
+    }
+  } else {
+    console.error(c.err.bold("\n  \u2717 ") + String(err));
+  }
+  console.log();
+}
+function showSuccess(msg) {
+  console.log(c.success.bold("\n  \u2713 ") + chalk.white(msg) + "\n");
+}
+function section(title) {
+  console.log("\n" + c.warm.bold("  " + title));
+  console.log(c.muted("  " + "\u2500".repeat(title.length + 2)) + "\n");
+}
+var WARM, PINK, COOL, SUCCESS, WARN, ERR, c, g0Gradient, coolGradient, BANNER_CACHE_DIR, BANNER_CACHE_FILE, BANNER_CACHE_TTL, BANNER_FETCH_TIMEOUT, BANNER_API_URL;
+var init_ui = __esm({
+  "src/lib/ui.ts"() {
+    "use strict";
+    WARM = "#FF6B35";
+    PINK = "#FF3CAC";
+    COOL = "#4CC9F0";
+    SUCCESS = "#00E676";
+    WARN = "#FFB300";
+    ERR = "#FF5252";
+    c = {
+      warm: chalk.hex(WARM),
+      pink: chalk.hex(PINK),
+      cool: chalk.hex(COOL),
+      success: chalk.hex(SUCCESS),
+      warn: chalk.hex(WARN),
+      err: chalk.hex(ERR),
+      muted: chalk.gray,
+      bold: chalk.bold,
+      dim: chalk.dim
+    };
+    g0Gradient = gradient([WARM, PINK]);
+    coolGradient = gradient([COOL, "#7B61FF"]);
+    BANNER_CACHE_DIR = join(homedir(), ".g0", "cache");
+    BANNER_CACHE_FILE = join(BANNER_CACHE_DIR, "motd.json");
+    BANNER_CACHE_TTL = 6 * 60 * 60 * 1e3;
+    BANNER_FETCH_TIMEOUT = 1500;
+    BANNER_API_URL = "https://g0hub.com/api/v1/cli/motd";
+  }
+});
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearAuth: () => clearAuth,
+  getAllConfig: () => getAllConfig,
+  getApiKey: () => getApiKey,
+  getApiUrl: () => getApiUrl,
+  getConfigPath: () => getConfigPath,
+  getConfigValue: () => getConfigValue,
+  getUserInfo: () => getUserInfo,
+  isAuthenticated: () => isAuthenticated,
+  setAuth: () => setAuth,
+  setConfigValue: () => setConfigValue
+});
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function ensureDir() {
+  if (!existsSync2(CONFIG_DIR)) {
+    mkdirSync2(CONFIG_DIR, { recursive: true });
+  }
+}
+function load() {
+  ensureDir();
+  try {
+    if (existsSync2(CONFIG_FILE)) {
+      return { ...DEFAULTS, ...JSON.parse(readFileSync2(CONFIG_FILE, "utf-8")) };
+    }
+  } catch {
+  }
+  return { ...DEFAULTS };
+}
+function save(config) {
+  ensureDir();
+  writeFileSync2(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getApiKey() {
+  return load().apiKey;
+}
+function getApiUrl() {
+  return load().apiUrl;
+}
+function isAuthenticated() {
+  return !!load().apiKey;
+}
+function setAuth(data) {
+  const config = load();
+  config.apiKey = data.apiKey;
+  config.userId = data.userId;
+  config.email = data.email;
+  config.name = data.name;
+  config.accountType = data.accountType;
+  save(config);
+}
+function clearAuth() {
+  const config = load();
+  config.apiKey = "";
+  config.userId = "";
+  config.email = "";
+  config.name = "";
+  config.accountType = "";
+  save(config);
+}
+function getUserInfo() {
+  const config = load();
+  return {
+    userId: config.userId,
+    email: config.email,
+    name: config.name,
+    accountType: config.accountType
+  };
+}
+function getConfigValue(key) {
+  return load()[key];
+}
+function setConfigValue(key, value) {
+  const config = load();
+  if (key in DEFAULTS) {
+    config[key] = value;
+    save(config);
+  }
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function getAllConfig() {
+  return load();
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULTS;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    CONFIG_DIR = join2(homedir2(), ".g0");
+    CONFIG_FILE = join2(CONFIG_DIR, "config.json");
+    DEFAULTS = {
+      apiKey: "",
+      apiUrl: "https://g0hub.com",
+      userId: "",
+      email: "",
+      name: "",
+      accountType: "",
+      theme: "dark"
+    };
+  }
+});
+
+// src/lib/api.ts
+async function request(path, options = {}) {
+  const { method = "GET", body, query, auth = true } = options;
+  const baseUrl = getApiUrl();
+  let url = `${baseUrl}/api/v1${path}`;
+  if (query) {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== "") params.set(k, v);
+    }
+    const qs = params.toString();
+    if (qs) url += `?${qs}`;
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": "@g0hub/cli/1.0.0"
+  };
+  if (auth) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+      throw new ApiError(
+        401,
+        'Not authenticated. Run "g0 login" or "g0 auth:key <api-key>" first.'
+      );
+    }
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) {
+    let errBody;
+    try {
+      errBody = await res.json();
+    } catch {
+      errBody = await res.text();
+    }
+    const msg = typeof errBody === "object" && errBody && "error" in errBody ? errBody.error : `HTTP ${res.status}`;
+    throw new ApiError(res.status, msg, errBody);
+  }
+  if (res.status === 204) return void 0;
+  return await res.json();
+}
+var ApiError, api;
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_config();
+    ApiError = class extends Error {
+      constructor(status, message, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "ApiError";
+      }
+    };
+    api = {
+      get: (path, query, auth = true) => request(path, { method: "GET", query, auth }),
+      post: (path, body, auth = true) => request(path, { method: "POST", body, auth }),
+      put: (path, body) => request(path, { method: "PUT", body }),
+      patch: (path, body) => request(path, { method: "PATCH", body }),
+      delete: (path) => request(path, { method: "DELETE" })
+    };
+  }
+});
+
+// src/commands/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  changePassword: () => changePassword,
+  forgotPassword: () => forgotPassword,
+  login: () => login,
+  logout: () => logout,
+  register: () => register,
+  resendVerification: () => resendVerification,
+  resetPassword: () => resetPassword,
+  setApiKey: () => setApiKey,
+  setConfigValue: () => setConfigValue2,
+  showConfig: () => showConfig,
+  whoami: () => whoami
+});
+import { input, password, select } from "@inquirer/prompts";
+async function login() {
+  banner();
+  console.log(c.warm.bold("  Sign in to g0\n"));
+  const email = await input({
+    message: "Email",
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const pass = await password({ message: "Password" });
+  const s = spin("Authenticating...");
+  try {
+    const res = await api.post("/auth/login", { email, password: pass, source: "cli" }, false);
+    if (!res.token) {
+      s.fail("Login succeeded but no API key was returned");
+      console.log(c.muted('\n  Use "g0 auth:key <api-key>" to authenticate with an existing key.\n'));
+      return;
+    }
+    setAuth({
+      apiKey: res.token,
+      userId: res.id,
+      email: res.email,
+      name: res.name || "",
+      accountType: res.accountType
+    });
+    s.succeed(c.success("Authenticated!"));
+    showSuccess(`Welcome back, ${c.warm.bold(res.name || res.email)}!`);
+  } catch (err) {
+    s.fail("Authentication failed");
+    showError(err);
+  }
+}
+async function register() {
+  banner();
+  console.log(c.warm.bold("  Create a g0 account\n"));
+  const name = await input({ message: "Name" });
+  const email = await input({
+    message: "Email",
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const pass = await password({
+    message: "Password",
+    validate: (v) => v.length >= 8 ? true : "Password must be at least 8 characters"
+  });
+  const accountType = await select({
+    message: "Account type",
+    choices: [
+      {
+        name: "Buyer \u2014 I want to hire AI agents",
+        value: "BUYER"
+      },
+      {
+        name: "Agentrepreneur \u2014 I build and sell AI agents",
+        value: "AGENTREPRENEUR"
+      },
+      {
+        name: "Both \u2014 I hire and sell agents",
+        value: "BOTH"
+      }
+    ]
+  });
+  const s = spin("Creating account...");
+  try {
+    const res = await api.post("/auth/register", { name, email, password: pass, accountType, source: "cli" }, false);
+    if (!res.token) {
+      s.fail("Account created but no API key was returned");
+      console.log(c.muted('\n  Use "g0 auth:key <api-key>" to authenticate with an existing key.\n'));
+      return;
+    }
+    setAuth({
+      apiKey: res.token,
+      userId: res.user.id,
+      email: res.user.email,
+      name: res.user.name || "",
+      accountType: res.user.accountType
+    });
+    s.succeed(c.success("Account created!"));
+    showSuccess(
+      `Welcome to g0, ${c.warm.bold(name)}! You're ready to ${accountType === "BUYER" ? "hire AI agents" : accountType === "AGENTREPRENEUR" ? "sell your AI agents" : "hire and sell AI agents"}.`
+    );
+  } catch (err) {
+    s.fail("Registration failed");
+    showError(err);
+  }
+}
+async function logout() {
+  if (!isAuthenticated()) {
+    console.log(c.muted("\n  Not logged in.\n"));
+    return;
+  }
+  const info = getUserInfo();
+  clearAuth();
+  showSuccess(`Signed out${info.email ? ` from ${c.muted(info.email)}` : ""}.`);
+}
+async function whoami() {
+  if (!isAuthenticated()) {
+    console.log(
+      c.warn("\n  Not authenticated.") + c.muted(' Run "g0 login" or "g0 register" to sign in.\n')
+    );
+    return;
+  }
+  const info = getUserInfo();
+  const s = spin("Fetching profile...");
+  try {
+    const res = await api.get("/user/profile");
+    const profile = res.user;
+    s.stop();
+    const profileLines = [
+      `${c.muted("Name:")}     ${c.bold(profile.name || "\u2014")}`,
+      `${c.muted("Email:")}    ${profile.email}`
+    ];
+    if (profile.bio) {
+      profileLines.push(`${c.muted("Bio:")}      ${profile.bio}`);
+    }
+    profileLines.push(
+      `${c.muted("Account:")}  ${c.warm(profile.accountType)}`,
+      `${c.muted("Balance:")}  ${c.success.bold("$" + parseFloat(profile.creditBalance).toFixed(2))} ${c.dim("USDC")}`,
+      `${c.muted("User ID:")}  ${c.dim(profile.id)}`,
+      `${c.muted("Since:")}    ${new Date(profile.createdAt).toLocaleDateString()}`
+    );
+    infoBox("Your Profile", profileLines);
+  } catch {
+    s.stop();
+    infoBox("Your Profile (cached)", [
+      `${c.muted("Name:")}     ${c.bold(info.name || "\u2014")}`,
+      `${c.muted("Email:")}    ${info.email}`,
+      `${c.muted("Account:")}  ${c.warm(info.accountType)}`,
+      `${c.muted("User ID:")}  ${c.dim(info.userId)}`
+    ]);
+  }
+  console.log();
+}
+async function forgotPassword() {
+  banner();
+  console.log(c.warm.bold("  Reset your password\n"));
+  const email = await input({
+    message: "Email",
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const s = spin("Sending reset email...");
+  try {
+    const res = await api.post(
+      "/auth/forgot-password",
+      { email },
+      false
+    );
+    s.succeed(c.success("Done"));
+    showSuccess(res.message);
+  } catch (err) {
+    s.fail("Request failed");
+    showError(err);
+  }
+}
+async function resetPassword() {
+  banner();
+  console.log(c.warm.bold("  Set a new password\n"));
+  const token = await input({ message: "Reset token" });
+  const email = await input({
+    message: "Email",
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const pass = await password({
+    message: "New password",
+    validate: (v) => v.length >= 8 ? true : "Password must be at least 8 characters"
+  });
+  const s = spin("Resetting password...");
+  try {
+    const res = await api.post(
+      "/auth/reset-password",
+      { token, email, password: pass },
+      false
+    );
+    s.succeed(c.success("Done"));
+    showSuccess(res.message);
+  } catch (err) {
+    s.fail("Reset failed");
+    showError(err);
+  }
+}
+async function resendVerification() {
+  banner();
+  console.log(c.warm.bold("  Resend verification email\n"));
+  const email = await input({
+    message: "Email",
+    validate: (v) => v.includes("@") ? true : "Enter a valid email"
+  });
+  const s = spin("Sending verification email...");
+  try {
+    const res = await api.post(
+      "/auth/resend-verification",
+      { email },
+      false
+    );
+    s.succeed(c.success("Done"));
+    showSuccess(res.message);
+  } catch (err) {
+    s.fail("Request failed");
+    showError(err);
+  }
+}
+async function changePassword() {
+  banner();
+  console.log(c.warm.bold("  Change your password\n"));
+  const currentPassword = await password({ message: "Current password" });
+  const newPassword = await password({
+    message: "New password",
+    validate: (v) => v.length >= 8 ? true : "Password must be at least 8 characters"
+  });
+  const s = spin("Updating password...");
+  try {
+    await api.post("/user/profile/password", {
+      currentPassword,
+      newPassword
+    });
+    s.succeed(c.success("Done"));
+    showSuccess("Password changed successfully.");
+  } catch (err) {
+    s.fail("Password change failed");
+    showError(err);
+  }
+}
+async function setApiKey(key) {
+  if (!key) {
+    const k = await input({ message: "Paste your API key" });
+    key = k;
+  }
+  const s = spin("Validating API key...");
+  try {
+    setAuth({ apiKey: key, userId: "", email: "", name: "", accountType: "" });
+    const res = await api.get("/user/profile");
+    const profile = res.user;
+    setAuth({
+      apiKey: key,
+      userId: profile.id,
+      email: profile.email,
+      name: profile.name || "",
+      accountType: profile.accountType
+    });
+    s.succeed(c.success("API key saved!"));
+    showSuccess(`Authenticated as ${c.warm.bold(profile.name || profile.email)}`);
+  } catch (err) {
+    clearAuth();
+    s.fail("Invalid API key");
+    showError(err);
+  }
+}
+async function showConfig() {
+  const conf = getAllConfig();
+  infoBox("Configuration", [
+    `${c.muted("API URL:")}     ${conf.apiUrl}`,
+    `${c.muted("API Key:")}     ${conf.apiKey ? c.success("\u25CF") + c.muted(" configured") : c.err("\u25CF") + c.muted(" not set")}`,
+    `${c.muted("Theme:")}       ${conf.theme}`,
+    `${c.muted("Config path:")} ${c.dim(getConfigPath())}`
+  ]);
+  console.log();
+}
+async function setConfigValue2(key, value) {
+  if (key === "apiUrl" || key === "theme") {
+    setConfigValue(key, value);
+    showSuccess(`${key} = ${value}`);
+  } else {
+    showError(
+      new Error(`Unknown config key "${key}". Valid keys: apiUrl, theme`)
+    );
+  }
+}
+var init_auth = __esm({
+  "src/commands/auth.ts"() {
+    "use strict";
+    init_api();
+    init_config();
+    init_ui();
+  }
+});
+
+// src/commands/profile.ts
+var profile_exports = {};
+__export(profile_exports, {
+  updateProfile: () => updateProfile,
+  viewProfile: () => viewProfile
+});
+import chalk2 from "chalk";
+import { input as input2, editor } from "@inquirer/prompts";
+function requireAuth() {
+  if (!isAuthenticated()) {
+    console.error(
+      c.err.bold("\n  \u2717 Not authenticated.") + c.muted('\n    Run "g0 login" or "g0 auth:key <key>" first.\n')
+    );
+    process.exit(1);
+  }
+}
+async function viewProfile() {
+  requireAuth();
+  const s = spin("Loading profile...");
+  try {
+    const data = await api.get("/user/profile");
+    s.stop();
+    const u = data.user;
+    const lines = [
+      `${c.muted("Email")}      ${u.email}`,
+      `${c.muted("Name")}       ${u.name || chalk2.dim("Not set")}`,
+      `${c.muted("Bio")}        ${u.bio || chalk2.dim("Not set")}`,
+      `${c.muted("Role")}       ${u.role}`,
+      `${c.muted("Type")}       ${u.accountType}`,
+      `${c.muted("Balance")}    $${Number(u.creditBalance).toFixed(2)}`,
+      `${c.muted("Joined")}     ${new Date(u.createdAt).toLocaleDateString()}`
+    ];
+    if (u.profileOverview) {
+      lines.push("");
+      lines.push(`${c.muted("Overview")}`);
+      const preview = u.profileOverview.length > 200 ? u.profileOverview.slice(0, 200) + "..." : u.profileOverview;
+      lines.push(`  ${preview}`);
+    }
+    infoBox("Your Profile", lines);
+    if (data.stats) {
+      console.log();
+      const statLines = [
+        `${c.muted("Tasks")}      ${data.stats.taskCount}`,
+        `${c.muted("Listings")}   ${data.stats.agentCount}`,
+        `${c.muted("Spent")}      $${Number(data.stats.totalSpent).toFixed(2)}`
+      ];
+      infoBox("Stats", statLines);
+    }
+  } catch (err) {
+    s.stop();
+    showError(err);
+  }
+}
+async function updateProfile() {
+  requireAuth();
+  const s = spin("Loading current profile...");
+  let current;
+  try {
+    const data = await api.get("/user/profile");
+    current = data.user;
+    s.stop();
+  } catch (err) {
+    s.stop();
+    showError(err);
+    return;
+  }
+  console.log(chalk2.bold("\nUpdate your profile (press Enter to keep current value)\n"));
+  const name = await input2({
+    message: "Display Name",
+    default: current.name || void 0
+  });
+  const bio = await input2({
+    message: "Bio (short, max 500 chars)",
+    default: current.bio || void 0
+  });
+  const editOverview = await input2({
+    message: "Edit profile overview? (y/N)",
+    default: "n"
+  });
+  let profileOverview;
+  if (editOverview.toLowerCase() === "y") {
+    profileOverview = await editor({
+      message: "Profile Overview (detailed, max 5000 chars)",
+      default: current.profileOverview || ""
+    });
+  }
+  const updates = {};
+  if (name && name !== current.name) updates.name = name;
+  if (bio !== void 0 && bio !== current.bio) updates.bio = bio;
+  if (profileOverview !== void 0 && profileOverview !== current.profileOverview) {
+    updates.profileOverview = profileOverview;
+  }
+  if (Object.keys(updates).length === 0) {
+    console.log(chalk2.dim("\nNo changes made."));
+    return;
+  }
+  const s2 = spin("Updating profile...");
+  try {
+    await api.patch("/user/profile", updates);
+    s2.stop();
+    showSuccess("Profile updated successfully!");
+  } catch (err) {
+    s2.stop();
+    showError(err);
+  }
+}
+var init_profile = __esm({
+  "src/commands/profile.ts"() {
+    "use strict";
+    init_api();
+    init_config();
+    init_ui();
+  }
+});
+
+// src/commands/wallet.ts
+var wallet_exports = {};
+__export(wallet_exports, {
+  getWallet: () => getWallet
+});
+async function getWallet() {
+  const s = spin("Loading wallet...");
+  try {
+    const res = await api.get("/user/wallet");
+    s.stop();
+    const balance = parseFloat(res.creditBalance || "0");
+    infoBox("Your Wallet", [
+      `${c.muted("Balance:")}        ${c.success.bold("$" + balance.toFixed(2))} ${c.dim("USDC")}`,
+      `${c.muted("EVM Address:")}    ${c.dim(res.wallet?.evmAddress || "\u2014")}`,
+      `${c.muted("Solana Address:")} ${c.dim(res.wallet?.solanaAddress || "\u2014")}`,
+      `${c.muted("Label:")}          ${res.wallet?.label || "\u2014"}`,
+      `${c.muted("Wallet ID:")}      ${c.dim(res.wallet?.id || "\u2014")}`
+    ]);
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load wallet");
+    showError(err);
+  }
+}
+var init_wallet = __esm({
+  "src/commands/wallet.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/marketplace.ts
+var marketplace_exports = {};
+__export(marketplace_exports, {
+  browse: () => browse,
+  search: () => search,
+  viewAgent: () => viewAgent,
+  viewAgentReviews: () => viewAgentReviews
+});
+import { input as input3, select as select2 } from "@inquirer/prompts";
+async function browse() {
+  banner();
+  const categories = [
+    "ALL",
+    "CODING",
+    "WEB_DEVELOPMENT",
+    "MOBILE_DEVELOPMENT",
+    "DATA_SCIENCE",
+    "DATA_INTELLIGENCE",
+    "DIGITAL_MARKETING",
+    "SEO",
+    "CONTENT_WRITING",
+    "GRAPHIC_DESIGN",
+    "VIDEO_GENERATION",
+    "AI_ML",
+    "CLOUD_COMPUTING",
+    "DATABASE_MANAGEMENT",
+    "DEVOPS",
+    "CYBERSECURITY",
+    "PRODUCT_MANAGEMENT",
+    "BLOCKCHAIN",
+    "RESEARCH",
+    "CUSTOMER_SUPPORT",
+    "AUTOMATION",
+    "API_INTEGRATION",
+    "FULL_STACK_TEAM",
+    "SALES",
+    "HR_RECRUITMENT",
+    "VOICE_AGENTS",
+    "LEGAL_COMPLIANCE",
+    "FINANCE_ACCOUNTING",
+    "AUDIO_MUSIC",
+    "EDUCATION_TRAINING"
+  ];
+  const category = await select2({
+    message: "Browse by category",
+    choices: categories.map((cat) => ({
+      name: cat === "ALL" ? "All Categories" : cat.replace(/_/g, " "),
+      value: cat
+    }))
+  });
+  const sort = await select2({
+    message: "Sort by",
+    choices: [
+      { name: "Reputation Score", value: "reputation" },
+      { name: "Trending", value: "trending" },
+      { name: "Rating", value: "rating" },
+      { name: "Most Tasks", value: "tasks_completed" },
+      { name: "Price: Low \u2192 High", value: "price_asc" },
+      { name: "Price: High \u2192 Low", value: "price_desc" },
+      { name: "Newest", value: "newest" }
+    ]
+  });
+  const query = { sort };
+  if (category !== "ALL") query.category = category;
+  await listAgents(query);
+}
+async function search(query) {
+  if (!query) {
+    query = await input3({ message: "Search agents" });
+  }
+  const s = spin(`Searching for "${query}"...`);
+  try {
+    const res = await api.get(
+      "/marketplace/search",
+      { q: query },
+      false
+    );
+    s.stop();
+    if (res.agents.length === 0) {
+      console.log(c.warn(`
+  No agents found matching "${query}"
+`));
+      return;
+    }
+    section(`${res.agents.length} results for "${query}"`);
+    printAgentTable(res.agents);
+  } catch (err) {
+    s.fail("Search failed");
+    showError(err);
+  }
+}
+async function listAgents(query) {
+  const s = spin("Loading marketplace...");
+  try {
+    const res = await api.get(
+      "/marketplace",
+      query,
+      false
+    );
+    s.stop();
+    if (res.agents.length === 0) {
+      console.log(c.warn("\n  No agents found.\n"));
+      return;
+    }
+    section(`${res.agents.length} agents`);
+    printAgentTable(res.agents);
+    const choices = res.agents.map((a) => ({
+      name: `${a.name} \u2014 ${a.tagline || a.categories[0]}`,
+      value: a.slug
+    }));
+    choices.push({ name: c.muted("\u2190 Back"), value: "__back" });
+    const selected = await select2({
+      message: "View agent details",
+      choices
+    });
+    if (selected !== "__back") {
+      await viewAgent(selected);
+    }
+  } catch (err) {
+    s.fail("Failed to load marketplace");
+    showError(err);
+  }
+}
+async function viewAgent(slugOrId) {
+  const s = spin("Loading agent...");
+  try {
+    const res = await api.get(
+      `/agents/${slugOrId}`,
+      void 0,
+      false
+    );
+    const agent = res.agent;
+    s.stop();
+    console.log();
+    const verified = agent.isVerified ? c.cool(" \u2713 Verified") : "";
+    console.log(
+      "  " + c.warm.bold(agent.name) + verified
+    );
+    console.log("  " + c.muted(agent.tagline || agent.description.slice(0, 100)));
+    console.log();
+    infoBox(agent.name, [
+      `${c.muted("Status:")}      ${formatStatus(agent.status)}`,
+      `${c.muted("Price:")}       ${formatPrice(agent.basePrice, agent.currency)}`,
+      `${c.muted("Rating:")}      ${formatRating(agent.avgRating, agent.reviewCount)}`,
+      `${c.muted("Rep Score:")}   ${formatRepScore(agent.reputationScore)}`,
+      `${c.muted("Tasks Done:")}  ${c.bold(String(agent.tasksCompleted))}`,
+      `${c.muted("Success:")}     ${agent.successRate.toFixed(1)}%`,
+      `${c.muted("Avg Response:")} ${agent.avgResponseMs < 6e4 ? `${(agent.avgResponseMs / 1e3).toFixed(1)}s` : `${Math.round(agent.avgResponseMs / 6e4)}m`}`,
+      `${c.muted("Categories:")}  ${agent.categories.map((cat) => c.cool(cat.replace(/_/g, " "))).join(", ")}`,
+      `${c.muted("Tags:")}        ${agent.tags.length > 0 ? agent.tags.join(", ") : c.dim("none")}`
+    ]);
+    if (agent.skills.length > 0) {
+      section("Skills");
+      const skillTable = createTable(["Skill", "Proficiency"]);
+      for (const skill of agent.skills) {
+        const bar = c.warm("\u2588".repeat(Math.round(skill.proficiency / 5))) + c.muted("\u2591".repeat(20 - Math.round(skill.proficiency / 5)));
+        skillTable.push([skill.name, `${bar} ${skill.proficiency}%`]);
+      }
+      console.log(skillTable.toString());
+    }
+    console.log(
+      c.muted("\n  Slug: ") + c.dim(agent.slug) + c.muted("  \u2022  ID: ") + c.dim(agent.id) + "\n"
+    );
+  } catch (err) {
+    s.fail("Failed to load agent");
+    showError(err);
+  }
+}
+function printAgentTable(agents) {
+  const table = createTable([
+    "#",
+    "Agent",
+    "Category",
+    "Score",
+    "Rating",
+    "Price",
+    "Tasks"
+  ]);
+  for (let i = 0; i < agents.length; i++) {
+    const a = agents[i];
+    const verified = a.isVerified ? c.cool(" \u2713") : "";
+    table.push([
+      c.dim(String(i + 1)),
+      c.bold(a.name) + verified + "\n" + c.muted(truncate(a.tagline || a.description, 40)),
+      c.cool(a.categories[0]?.replace(/_/g, " ") || "\u2014"),
+      formatRepScore(a.reputationScore),
+      a.avgRating > 0 ? formatRating(a.avgRating) : c.muted("\u2014"),
+      formatPrice(a.basePrice),
+      String(a.tasksCompleted)
+    ]);
+  }
+  console.log(table.toString());
+  console.log();
+}
+async function viewAgentReviews(slug) {
+  const s = spin("Loading reviews...");
+  try {
+    const res = await api.get(`/agents/${slug}`, void 0, false);
+    s.stop();
+    const { agent } = res;
+    if (!agent.reviews || agent.reviews.length === 0) {
+      console.log(c.warn(`
+  No reviews for ${c.warm.bold(agent.name)} yet.
+`));
+      return;
+    }
+    section(`Reviews for ${agent.name} \u2014 ${formatRating(agent.avgRating, agent.reviewCount)}`);
+    const table = createTable(["Rating", "Reviewer", "Date", "Review"]);
+    for (const r of agent.reviews) {
+      const stars = formatRating(r.rating);
+      const reviewer = r.author?.name || c.muted("Anonymous");
+      const content = r.title ? c.bold(r.title) + "\n" + (r.content || "") : r.content || c.muted("No comment");
+      const truncated = content.length > 80 ? content.slice(0, 77) + "..." : content;
+      table.push([stars, reviewer, formatDate(r.createdAt), truncated]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load reviews");
+    showError(err);
+  }
+}
+function truncate(s, len) {
+  return s.length > len ? s.slice(0, len - 1) + "\u2026" : s;
+}
+var init_marketplace = __esm({
+  "src/commands/marketplace.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/tasks.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  acceptTaskProposal: () => acceptTaskProposal,
+  hire: () => hire,
+  listTaskProposals: () => listTaskProposals,
+  listTasks: () => listTasks,
+  review: () => review,
+  sendMessage: () => sendMessage,
+  viewTask: () => viewTask
+});
+import { input as input4, select as select3, number as numPrompt, editor as editor2 } from "@inquirer/prompts";
+async function hire(agentSlug) {
+  if (!agentSlug) {
+    agentSlug = await input4({ message: "Agent slug or ID" });
+  }
+  const s = spin("Loading agent...");
+  let agent;
+  try {
+    const agentRes = await api.get(`/agents/${agentSlug}`, void 0, false);
+    agent = agentRes.agent;
+    s.stop();
+  } catch (err) {
+    s.fail("Agent not found");
+    showError(err);
+    return;
+  }
+  console.log(
+    `
+  Hiring ${c.warm.bold(agent.name)} ${c.muted(`(starting at ${formatPrice(agent.basePrice, agent.currency)})`)}
+`
+  );
+  const title = await input4({
+    message: "Task title",
+    validate: (v) => v.length > 3 ? true : "Title must be at least 4 characters"
+  });
+  const description = await editor2({
+    message: "Task description (opens editor)",
+    default: "Describe what you need done...",
+    waitForUseInput: false
+  });
+  const category = await select3({
+    message: "Category",
+    choices: agent.categories.map((cat) => ({
+      name: cat.replace(/_/g, " "),
+      value: cat
+    })),
+    default: agent.categories[0]
+  });
+  const budget = await numPrompt({
+    message: `Budget (${agent.currency})`,
+    default: parseFloat(agent.basePrice),
+    min: 0.01
+  });
+  const priority = await select3({
+    message: "Priority",
+    choices: [
+      { name: "Normal", value: "NORMAL" },
+      { name: "Low", value: "LOW" },
+      { name: "High", value: "HIGH" },
+      { name: "Urgent", value: "URGENT" }
+    ],
+    default: "NORMAL"
+  });
+  const s2 = spin("Creating task...");
+  try {
+    const res = await api.post("/tasks", {
+      title,
+      description,
+      category,
+      budget: budget ?? parseFloat(agent.basePrice),
+      currency: agent.currency,
+      agentId: agent.id,
+      priority
+    });
+    s2.succeed(c.success("Task created!"));
+    showSuccess(
+      `Task ${c.warm.bold(res.taskId.slice(0, 8))} created for ${c.warm(res.agent?.name || agent.name)}`
+    );
+    console.log(c.muted(`  Track: g0 task ${res.taskId}
+`));
+  } catch (err) {
+    s2.fail("Failed to create task");
+    showError(err);
+  }
+}
+async function listTasks(opts) {
+  const s = spin("Loading tasks...");
+  try {
+    const query = {};
+    if (opts.status) query.status = opts.status;
+    if (opts.limit) query.limit = opts.limit;
+    const res = await api.get("/tasks", query);
+    s.stop();
+    if (res.tasks.length === 0) {
+      console.log(c.warn("\n  No tasks found.\n"));
+      return;
+    }
+    section(`Your Tasks (${res.tasks.length})`);
+    const table = createTable(["ID", "Title", "Agent", "Status", "Budget", "Created"]);
+    for (const t of res.tasks) {
+      table.push([
+        c.dim(t.id.slice(0, 8)),
+        c.bold(t.title),
+        t.agent ? c.warm(t.agent.name) : c.muted("unassigned"),
+        formatStatus(t.status),
+        formatPrice(t.budget, t.currency),
+        formatDate(t.createdAt)
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load tasks");
+    showError(err);
+  }
+}
+async function viewTask(taskId) {
+  const s = spin("Loading task...");
+  try {
+    const res = await api.get(`/tasks/${taskId}`);
+    const task = res.task;
+    s.stop();
+    infoBox(`Task: ${task.title}`, [
+      `${c.muted("ID:")}         ${c.dim(task.id)}`,
+      `${c.muted("Status:")}     ${formatStatus(task.status)}`,
+      `${c.muted("Agent:")}      ${task.agent ? c.warm.bold(task.agent.name) : c.muted("unassigned")}`,
+      `${c.muted("Category:")}   ${c.cool(task.category.replace(/_/g, " "))}`,
+      `${c.muted("Priority:")}   ${task.priority}`,
+      `${c.muted("Budget:")}     ${formatPrice(task.budget, task.currency)}`,
+      `${c.muted("Progress:")}   ${progressBar(task.progress)} ${task.progress}%`,
+      `${c.muted("Created:")}    ${formatDate(task.createdAt)}`,
+      ...task.startedAt ? [`${c.muted("Started:")}    ${formatDate(task.startedAt)}`] : [],
+      ...task.completedAt ? [`${c.muted("Completed:")}  ${formatDate(task.completedAt)}`] : []
+    ]);
+    if (task.progressMessage) {
+      console.log(c.muted("\n  Latest update: ") + task.progressMessage);
+    }
+    if (task.resultSummary) {
+      section("Result");
+      console.log("  " + task.resultSummary + "\n");
+    }
+    console.log(c.muted("\n  Description:"));
+    console.log("  " + task.description.split("\n").join("\n  ") + "\n");
+    const messages = task.messages || [];
+    if (messages.length > 0) {
+      section("Messages");
+      for (const msg of messages) {
+        const sender = msg.senderType === "BUYER" ? c.cool("You") : msg.senderType === "AGENT" ? c.warm("Agent") : c.muted("System");
+        console.log(`  ${sender} ${c.dim(formatDate(msg.createdAt))}`);
+        console.log(`  ${msg.content}
+`);
+      }
+    }
+  } catch (err) {
+    s.fail("Failed to load task");
+    showError(err);
+  }
+}
+async function sendMessage(taskId) {
+  const content = await input4({
+    message: "Message",
+    validate: (v) => v.length > 0 ? true : "Message cannot be empty"
+  });
+  const s = spin("Sending...");
+  try {
+    await api.post(`/tasks/${taskId}/messages`, { content });
+    s.succeed(c.success("Message sent!"));
+  } catch (err) {
+    s.fail("Failed to send message");
+    showError(err);
+  }
+}
+async function review(taskId) {
+  const rating = await select3({
+    message: "Overall rating",
+    choices: [5, 4, 3, 2, 1].map((n) => ({
+      name: "\u2605".repeat(n) + "\u2606".repeat(5 - n) + ` (${n})`,
+      value: n
+    }))
+  });
+  const title = await input4({ message: "Review title (optional)" });
+  const content = await input4({ message: "Review comment (optional)" });
+  const s = spin("Submitting review...");
+  try {
+    await api.post(`/tasks/${taskId}/review`, {
+      rating,
+      title: title || void 0,
+      content: content || void 0
+    });
+    s.succeed(c.success("Review submitted!"));
+    showSuccess("Thank you for your feedback!");
+  } catch (err) {
+    s.fail("Failed to submit review");
+    showError(err);
+  }
+}
+async function listTaskProposals(taskId) {
+  const s = spin("Loading proposals...");
+  try {
+    const res = await api.get(`/tasks/${taskId}/proposals`);
+    s.stop();
+    if (res.proposals.length === 0) {
+      console.log(c.warn("\n  No proposals received yet.\n"));
+      return;
+    }
+    section(`Proposals (${res.count})`);
+    const table = createTable(["#", "Agent", "Price", "Rating", "Score", "Est. Time", "Approach"]);
+    for (let i = 0; i < res.proposals.length; i++) {
+      const p = res.proposals[i];
+      const estTime = p.estimatedMinutes < 60 ? `${p.estimatedMinutes}m` : `${Math.round(p.estimatedMinutes / 60)}h`;
+      const approach = p.approach.length > 50 ? p.approach.slice(0, 47) + "..." : p.approach;
+      table.push([
+        c.dim(String(i + 1)),
+        c.warm.bold(p.agentName) + "\n" + c.dim(p.agentSlug),
+        formatPrice(p.price, p.currency),
+        p.avgRating > 0 ? formatRating(p.avgRating) : c.muted("\u2014"),
+        formatRepScore(p.reputationScore),
+        c.cool(estTime),
+        approach
+      ]);
+    }
+    console.log(table.toString());
+    console.log(c.muted(`
+  Accept a proposal: g0 task:accept-proposal ${taskId}
+`));
+  } catch (err) {
+    s.fail("Failed to load proposals");
+    showError(err);
+  }
+}
+async function acceptTaskProposal(taskId) {
+  const s = spin("Loading proposals...");
+  try {
+    const res = await api.get(`/tasks/${taskId}/proposals`);
+    s.stop();
+    if (res.proposals.length === 0) {
+      console.log(c.warn("\n  No proposals to accept.\n"));
+      return;
+    }
+    const { select: select12 } = await import("@inquirer/prompts");
+    const proposalId = await select12({
+      message: "Select a proposal to accept",
+      choices: res.proposals.map((p) => ({
+        name: `${p.agentName} \u2014 ${formatPrice(p.price, p.currency)} \u2014 ${p.approach.slice(0, 50)}`,
+        value: p.proposalId
+      }))
+    });
+    const s2 = spin("Accepting proposal...");
+    const acceptRes = await api.post(`/tasks/${taskId}/proposals`, { proposalId });
+    s2.succeed(c.success("Proposal accepted!"));
+    showSuccess(acceptRes.message);
+    if (acceptRes.task?.agent) {
+      console.log(c.muted(`  Agent: ${c.warm(acceptRes.task.agent.name)}`));
+    }
+    console.log(c.muted(`  Track: g0 task ${taskId}
+`));
+  } catch (err) {
+    showError(err);
+  }
+}
+function progressBar(pct) {
+  const filled = Math.round(pct / 5);
+  return c.warm("\u2588".repeat(filled)) + c.muted("\u2591".repeat(20 - filled));
+}
+var init_tasks = __esm({
+  "src/commands/tasks.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/orders.ts
+var orders_exports = {};
+__export(orders_exports, {
+  createOrder: () => createOrder,
+  listOrders: () => listOrders
+});
+import { input as input5, select as select4, number as numPrompt2 } from "@inquirer/prompts";
+async function createOrder() {
+  const agentId = await input5({ message: "Agent ID or slug", validate: (v) => v.length > 0 || "Required" });
+  const title = await input5({ message: "Task title", validate: (v) => v.length > 3 || "Min 4 chars" });
+  const description = await input5({ message: "Task description", validate: (v) => v.length > 10 || "Min 10 chars" });
+  const category = await select4({
+    message: "Category",
+    choices: [
+      { name: "Coding", value: "CODING" },
+      { name: "Web Development", value: "WEB_DEVELOPMENT" },
+      { name: "Data Science", value: "DATA_SCIENCE" },
+      { name: "AI/ML", value: "AI_ML" },
+      { name: "Content Writing", value: "CONTENT_WRITING" },
+      { name: "Digital Marketing", value: "DIGITAL_MARKETING" },
+      { name: "Graphic Design", value: "GRAPHIC_DESIGN" },
+      { name: "Other", value: "OTHER" }
+    ]
+  });
+  const budget = await numPrompt2({ message: "Budget (USDC)", min: 0.01, default: 5 });
+  const s = spin("Creating order...");
+  try {
+    const res = await api.post("/orders", {
+      agentId,
+      title,
+      description,
+      category,
+      budget: budget ?? 5
+    });
+    s.succeed(c.success("Order created!"));
+    showSuccess(`Task ${c.dim(res.taskId.slice(0, 8))} created. Status: ${formatStatus(res.status)}`);
+    console.log(c.muted(`  Charged: ${formatPrice(res.totalEscrow)}`));
+    console.log(c.muted(`  Track: g0 task ${res.taskId}
+`));
+  } catch (err) {
+    s.fail("Failed to create order");
+    showError(err);
+  }
+}
+async function listOrders() {
+  const s = spin("Loading orders...");
+  try {
+    const res = await api.get("/orders");
+    s.stop();
+    if (res.orders.length === 0) {
+      console.log(c.warn("\n  No orders found.\n"));
+      return;
+    }
+    section(`Your Orders (${res.orders.length})`);
+    const table = createTable(["ID", "Title", "Agent", "Status", "Amount", "Date"]);
+    for (const o of res.orders) {
+      table.push([c.dim(o.id.slice(0, 8)), c.bold(o.title), c.warm(o.agent?.name || "\u2014"), formatStatus(o.status), formatPrice(o.budget, o.currency), formatDate(o.createdAt)]);
+    }
+    console.log(table.toString() + "\n");
+  } catch (err) {
+    s.fail("Failed to load orders");
+    showError(err);
+  }
+}
+var init_orders = __esm({
+  "src/commands/orders.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/jobs.ts
+var jobs_exports = {};
+__export(jobs_exports, {
+  acceptJobProposal: () => acceptJobProposal,
+  createJob: () => createJob,
+  listJobProposals: () => listJobProposals,
+  listJobs: () => listJobs
+});
+import { input as input6, select as select5, number as numPrompt3, editor as editor3 } from "@inquirer/prompts";
+async function createJob() {
+  const title = await input6({ message: "Job title", validate: (v) => v.length > 3 || "Min 4 chars" });
+  const description = await editor3({ message: "Job description (opens editor)", default: "Describe the job requirements..." });
+  const category = await select5({
+    message: "Category",
+    choices: [
+      { name: "Coding", value: "CODING" },
+      { name: "Web Development", value: "WEB_DEVELOPMENT" },
+      { name: "Data Science", value: "DATA_SCIENCE" },
+      { name: "AI/ML", value: "AI_ML" },
+      { name: "Content Writing", value: "CONTENT_WRITING" },
+      { name: "Digital Marketing", value: "DIGITAL_MARKETING" },
+      { name: "Graphic Design", value: "GRAPHIC_DESIGN" },
+      { name: "Other", value: "OTHER" }
+    ]
+  });
+  const budget = await numPrompt3({ message: "Budget (USDC)", min: 0.01, default: 10 });
+  const priority = await select5({
+    message: "Priority",
+    choices: [{ name: "Normal", value: "NORMAL" }, { name: "Low", value: "LOW" }, { name: "High", value: "HIGH" }, { name: "Urgent", value: "URGENT" }],
+    default: "NORMAL"
+  });
+  const s = spin("Posting job...");
+  try {
+    const res = await api.post("/jobs", { title, description, category, budgetMin: 1, budgetMax: budget ?? 10, requiredSkills: [], proposalDeadlineDays: 14 });
+    s.succeed(c.success("Job posted!"));
+    showSuccess(`Job ${c.warm.bold(res.job.title)} is live. Agents can now submit proposals.`);
+    console.log(c.muted(`  Job ID: ${res.job.id}`));
+    console.log(c.muted(`  View proposals: g0 jobs:proposals ${res.job.id}
+`));
+  } catch (err) {
+    s.fail("Failed to post job");
+    showError(err);
+  }
+}
+async function listJobs() {
+  const s = spin("Loading jobs...");
+  try {
+    const res = await api.get("/jobs");
+    s.stop();
+    if (res.jobs.length === 0) {
+      console.log(c.warn("\n  No jobs found.\n"));
+      return;
+    }
+    section(`Your Jobs (${res.jobs.length})`);
+    const table = createTable(["ID", "Title", "Category", "Budget", "Proposals", "Status", "Posted"]);
+    for (const j of res.jobs) {
+      const budgetStr = j.budgetMin && j.budgetMax ? `${formatPrice(j.budgetMin, j.currency)} - ${formatPrice(j.budgetMax, j.currency)}` : formatPrice(j.budgetMax || "0", j.currency);
+      table.push([c.dim(j.id.slice(0, 8)), c.bold(j.title), c.cool(j.category.replace(/_/g, " ")), budgetStr, c.warm(String(j.proposalCount)), formatStatus(j.status), formatDate(j.createdAt)]);
+    }
+    console.log(table.toString() + "\n");
+  } catch (err) {
+    s.fail("Failed to load jobs");
+    showError(err);
+  }
+}
+async function listJobProposals(taskId) {
+  const s = spin("Loading proposals...");
+  try {
+    const res = await api.get(`/jobs/${taskId}/proposals`);
+    s.stop();
+    if (res.proposals.length === 0) {
+      console.log(c.warn("\n  No proposals yet.\n"));
+      return;
+    }
+    section(`Proposals (${res.proposals.length})`);
+    const table = createTable(["#", "Agent", "Price", "Time Est.", "Status", "Submitted"]);
+    res.proposals.forEach((p, i) => {
+      table.push([c.dim(String(i + 1)), c.warm.bold(p.agent.name), formatPrice(p.price, p.currency), c.muted(`${p.estimatedHours}h`), formatStatus(p.status), formatDate(p.createdAt)]);
+    });
+    console.log(table.toString());
+    for (const p of res.proposals) {
+      if (p.approach) {
+        console.log(`
+  ${c.warm.bold(p.agent.name)}: ${c.muted(p.approach)}`);
+      }
+    }
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load proposals");
+    showError(err);
+  }
+}
+async function acceptJobProposal(taskId) {
+  const s = spin("Loading proposals...");
+  try {
+    const res = await api.get(`/jobs/${taskId}/proposals`);
+    s.stop();
+    if (res.proposals.length === 0) {
+      console.log(c.warn("\n  No proposals to accept.\n"));
+      return;
+    }
+    const proposalId = await select5({
+      message: "Select proposal to accept",
+      choices: res.proposals.map((p) => ({
+        name: `${p.agent.name} \u2014 ${formatPrice(p.price, p.currency)}`,
+        value: p.id
+      }))
+    });
+    const s2 = spin("Accepting proposal...");
+    try {
+      await api.post(`/jobs/${taskId}/accept`, { proposalId });
+      s2.succeed(c.success("Proposal accepted!"));
+      showSuccess("Task created from accepted proposal. Escrow has been charged.");
+    } catch (err) {
+      s2.fail("Failed to accept proposal");
+      showError(err);
+    }
+  } catch (err) {
+    s.fail("Failed to load proposals");
+    showError(err);
+  }
+}
+var init_jobs = __esm({
+  "src/commands/jobs.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/hire.ts
+var hire_exports = {};
+__export(hire_exports, {
+  createHireRequest: () => createHireRequest,
+  listHireRequests: () => listHireRequests,
+  payHireRequest: () => payHireRequest,
+  respondToHireRequest: () => respondToHireRequest,
+  viewHireRequest: () => viewHireRequest
+});
+import { input as input7, select as select6, number as numPrompt4, confirm } from "@inquirer/prompts";
+async function createHireRequest() {
+  const agentId = await input7({ message: "Agent ID or slug", validate: (v) => v.length > 0 || "Required" });
+  const title = await input7({ message: "Project title", validate: (v) => v.length > 3 || "Min 4 chars" });
+  const description = await input7({ message: "Describe what you need", validate: (v) => v.length > 10 || "Min 10 chars" });
+  const budget = await numPrompt4({ message: "Proposed budget (USDC)", min: 0.01, default: 10 });
+  const s = spin("Sending hire request...");
+  try {
+    const res = await api.post("/hire-requests", {
+      agentId,
+      title,
+      description,
+      deliverables: [{ item: title }],
+      price: budget ?? 10
+    });
+    s.succeed(c.success("Hire request sent!"));
+    showSuccess(`Request ${c.dim(res.hireRequest.id.slice(0, 8))} sent. The agent will review and respond.`);
+  } catch (err) {
+    s.fail("Failed to send hire request");
+    showError(err);
+  }
+}
+async function listHireRequests() {
+  const s = spin("Loading hire requests...");
+  try {
+    const res = await api.get("/hire-requests");
+    s.stop();
+    if (res.hireRequests.length === 0) {
+      console.log(c.warn("\n  No hire requests found.\n"));
+      return;
+    }
+    section(`Hire Requests (${res.hireRequests.length})`);
+    const table = createTable(["ID", "Title", "Agent", "Budget", "Status", "Sent"]);
+    for (const r of res.hireRequests) {
+      table.push([c.dim(r.id.slice(0, 8)), c.bold(r.title), c.warm(r.agent?.name || "\u2014"), formatPrice(r.price, r.currency), formatStatus(r.status), formatDate(r.createdAt)]);
+    }
+    console.log(table.toString() + "\n");
+  } catch (err) {
+    s.fail("Failed to load hire requests");
+    showError(err);
+  }
+}
+async function viewHireRequest(requestId) {
+  const s = spin("Loading hire request...");
+  try {
+    const res = await api.get(`/hire-requests/${requestId}`);
+    const r = res.hireRequest;
+    s.stop();
+    infoBox(`Hire Request: ${r.title}`, [
+      `${c.muted("ID:")}       ${c.dim(r.id)}`,
+      `${c.muted("Agent:")}    ${c.warm.bold(r.agent?.name || "\u2014")}`,
+      `${c.muted("Budget:")}   ${formatPrice(r.price, r.currency)}`,
+      `${c.muted("Status:")}   ${formatStatus(r.status)}`,
+      ...r.counterPrice ? [`${c.muted("Counter:")}  ${formatPrice(r.counterPrice, r.currency)}`] : [],
+      ...r.responseNote ? [`${c.muted("Message:")}  ${r.responseNote}`] : [],
+      `${c.muted("Sent:")}     ${formatDate(r.createdAt)}`
+    ]);
+    if (r.description) {
+      console.log(c.muted("\n  Description:"));
+      console.log("  " + r.description + "\n");
+    }
+  } catch (err) {
+    s.fail("Failed to load hire request");
+    showError(err);
+  }
+}
+async function respondToHireRequest(requestId) {
+  const action = await select6({
+    message: "How do you want to respond?",
+    choices: [
+      { name: "Accept \u2014 agree to the hire request", value: "accept" },
+      { name: "Reject \u2014 decline the hire request", value: "reject" },
+      { name: "Negotiate \u2014 propose a counter price", value: "negotiate" }
+    ]
+  });
+  let note;
+  let counterPrice;
+  if (action === "negotiate") {
+    counterPrice = await numPrompt4({ message: "Counter price (USDC)", min: 0.01 }) ?? void 0;
+    if (!counterPrice) {
+      console.log(c.err("\n  Counter price is required for negotiation.\n"));
+      return;
+    }
+  }
+  note = await input7({ message: "Note (optional)" }) || void 0;
+  const s = spin("Sending response...");
+  try {
+    const body = { action };
+    if (note) body.note = note;
+    if (counterPrice) body.counterPrice = counterPrice;
+    const res = await api.post(`/hire-requests/${requestId}`, body);
+    s.succeed(c.success("Response sent!"));
+    if (action === "accept" && res.taskId) {
+      showSuccess(`Hire request accepted. Task ${c.dim(res.taskId.slice(0, 8))} created.`);
+      if (res.totalEscrow) console.log(c.muted(`  Escrow: ${formatPrice(res.totalEscrow)}`));
+      if (res.newBalance) console.log(c.muted(`  New balance: ${formatPrice(res.newBalance)}`));
+    } else if (action === "accept") {
+      showSuccess("Hire request accepted.");
+    } else if (action === "reject") {
+      showSuccess("Hire request rejected.");
+    } else {
+      showSuccess(`Counter-offer sent: ${formatPrice(counterPrice)}`);
+    }
+    console.log();
+  } catch (err) {
+    s.fail("Failed to respond");
+    showError(err);
+  }
+}
+async function payHireRequest(requestId) {
+  const yes = await confirm({ message: "Confirm payment? Funds will be held in escrow.", default: true });
+  if (!yes) {
+    console.log(c.muted("\n  Cancelled.\n"));
+    return;
+  }
+  const s = spin("Processing payment...");
+  try {
+    const res = await api.post(`/hire-requests/${requestId}/pay`);
+    s.succeed(c.success("Payment processed!"));
+    showSuccess(`Escrow funded. Task ${c.dim(res.taskId.slice(0, 8))} created.`);
+    console.log(c.muted(`  Charged: ${formatPrice(res.totalEscrow)}`));
+    console.log(c.muted(`  Track: g0 task ${res.taskId}
+`));
+  } catch (err) {
+    s.fail("Payment failed");
+    showError(err);
+  }
+}
+var init_hire = __esm({
+  "src/commands/hire.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/inquiries.ts
+var inquiries_exports = {};
+__export(inquiries_exports, {
+  convertInquiryToTask: () => convertInquiryToTask,
+  createInquiry: () => createInquiry,
+  listInquiries: () => listInquiries,
+  sendInquiryMessage: () => sendInquiryMessage,
+  viewInquiry: () => viewInquiry
+});
+import { input as input8, select as select7 } from "@inquirer/prompts";
+async function createInquiry() {
+  const agentId = await input8({ message: "Agent ID or slug", validate: (v) => v.length > 0 || "Required" });
+  const subject = await input8({ message: "Subject", validate: (v) => v.length > 0 || "Subject required" });
+  const message = await input8({ message: "Your message", validate: (v) => v.length > 0 || "Message required" });
+  const s = spin("Starting inquiry...");
+  try {
+    const res = await api.post("/inquiries", { agentId, subject, message });
+    s.succeed(c.success("Inquiry started!"));
+    showSuccess(`Inquiry ${c.dim(res.inquiry.id.slice(0, 8))} created. The agent owner will respond.`);
+    console.log(c.muted(`  Continue: g0 inquiries:view ${res.inquiry.id}
+`));
+  } catch (err) {
+    s.fail("Failed to start inquiry");
+    showError(err);
+  }
+}
+async function listInquiries() {
+  const s = spin("Loading inquiries...");
+  try {
+    const res = await api.get("/inquiries");
+    s.stop();
+    if (res.inquiries.length === 0) {
+      console.log(c.warn("\n  No inquiries found.\n"));
+      return;
+    }
+    section(`Your Inquiries (${res.inquiries.length})`);
+    const table = createTable(["ID", "Subject", "With", "Status", "Messages", "Last Message", "Updated"]);
+    for (const i of res.inquiries) {
+      const lastContent = i.lastMessage?.content || "";
+      const preview = lastContent ? lastContent.length > 30 ? lastContent.slice(0, 30) + "..." : lastContent : c.muted("--");
+      table.push([c.dim(i.id.slice(0, 8)), c.bold(i.subject || "\u2014"), c.warm(i.counterparty?.name || "\u2014"), formatStatus(i.status), String(i.messageCount), preview, formatDate(i.updatedAt)]);
+    }
+    console.log(table.toString() + "\n");
+  } catch (err) {
+    s.fail("Failed to load inquiries");
+    showError(err);
+  }
+}
+async function viewInquiry(inquiryId) {
+  const s = spin("Loading inquiry...");
+  try {
+    const res = await api.get(`/inquiries/${inquiryId}`);
+    s.stop();
+    console.log(`
+  ${c.warm.bold("Inquiry")} with ${c.cool(res.counterparty?.name || "Agent")} ${c.dim(`(${formatStatus(res.inquiry.status)})`)}
+`);
+    for (const msg of res.messages) {
+      const sender = msg.senderType === "BUYER" ? c.cool("You") : c.warm("Agent");
+      console.log(`  ${sender} ${c.dim(formatDate(msg.createdAt))}`);
+      console.log(`  ${msg.content}
+`);
+    }
+  } catch (err) {
+    s.fail("Failed to load inquiry");
+    showError(err);
+  }
+}
+async function sendInquiryMessage(inquiryId) {
+  const content = await input8({ message: "Message", validate: (v) => v.length > 0 || "Message required" });
+  const s = spin("Sending...");
+  try {
+    await api.post(`/inquiries/${inquiryId}`, { content });
+    s.succeed(c.success("Message sent!"));
+  } catch (err) {
+    s.fail("Failed to send message");
+    showError(err);
+  }
+}
+async function convertInquiryToTask(inquiryId) {
+  const title = await input8({ message: "Task title", validate: (v) => v.length > 3 || "Min 4 chars" });
+  const description = await input8({ message: "Task description", validate: (v) => v.length > 10 || "Min 10 chars" });
+  const category = await select7({
+    message: "Category",
+    choices: [
+      { name: "Coding", value: "CODING" },
+      { name: "Web Development", value: "WEB_DEVELOPMENT" },
+      { name: "Data Science", value: "DATA_SCIENCE" },
+      { name: "AI/ML", value: "AI_ML" },
+      { name: "Content Writing", value: "CONTENT_WRITING" },
+      { name: "Other", value: "OTHER" }
+    ]
+  });
+  const price = await input8({ message: "Agreed price (USDC)", validate: (v) => !isNaN(parseFloat(v)) || "Must be a number" });
+  const s = spin("Converting to task...");
+  try {
+    const res = await api.post(`/inquiries/${inquiryId}/hire`, {
+      title,
+      description,
+      category,
+      agreedPrice: parseFloat(price)
+    });
+    s.succeed(c.success("Task created!"));
+    showSuccess(`Inquiry converted to task ${c.dim(res.taskId.slice(0, 8))}. Escrow charged.`);
+    console.log(c.muted(`  New balance: $${parseFloat(res.newBalance).toFixed(2)} USDC
+`));
+  } catch (err) {
+    s.fail("Failed to convert inquiry");
+    showError(err);
+  }
+}
+var init_inquiries = __esm({
+  "src/commands/inquiries.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/dashboard.ts
+var dashboard_exports = {};
+__export(dashboard_exports, {
+  completeTask: () => completeTask,
+  dashboardStats: () => dashboardStats,
+  disputeTask: () => disputeTask,
+  submitBuyerEvidence: () => submitBuyerEvidence
+});
+import { input as input9, confirm as confirm2 } from "@inquirer/prompts";
+async function dashboardStats() {
+  const s = spin("Loading dashboard...");
+  try {
+    const res = await api.get("/dashboard/stats");
+    s.stop();
+    infoBox("Dashboard", [
+      `${c.muted("Total Tasks:")}     ${c.bold(String(res.totalTasks))}`,
+      `${c.muted("Completed:")}       ${c.success(String(res.completedTasks))}`,
+      `${c.muted("Active:")}          ${c.cool(String(res.activeTasks))}`,
+      `${c.muted("Total Spent:")}     ${formatPrice(res.totalSpent)}`,
+      `${c.muted("Active Agents:")}   ${c.warm(String(res.activeAgents))}`,
+      `${c.muted("Active Listings:")} ${String(res.activeListings)}`,
+      `${c.muted("Avg Rating:")}      ${res.avgRating > 0 ? `\u2605 ${res.avgRating.toFixed(1)}` : c.muted("\u2014")}`
+    ]);
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load dashboard");
+    showError(err);
+  }
+}
+async function completeTask(taskId) {
+  const yes = await confirm2({ message: "Approve delivery and release escrow to the agent?", default: true });
+  if (!yes) {
+    console.log(c.muted("\n  Cancelled.\n"));
+    return;
+  }
+  const s = spin("Completing task...");
+  try {
+    await api.post(`/dashboard/tasks/${taskId}/complete`);
+    s.succeed(c.success("Task completed!"));
+    showSuccess("Escrow released to the agent. You can now leave a review.");
+    console.log(c.muted(`  Leave review: g0 review ${taskId}
+`));
+  } catch (err) {
+    s.fail("Failed to complete task");
+    showError(err);
+  }
+}
+async function disputeTask(taskId) {
+  const reason = await input9({ message: "Reason for dispute", validate: (v) => v.length > 10 || "Min 10 chars" });
+  const s = spin("Filing dispute...");
+  try {
+    await api.post(`/dashboard/tasks/${taskId}/dispute`, { message: reason });
+    s.succeed(c.success("Dispute filed."));
+    showSuccess("The agent will be notified and can respond or redeliver.");
+    console.log(c.muted(`  Submit evidence: g0 dashboard:evidence ${taskId}
+`));
+  } catch (err) {
+    s.fail("Failed to file dispute");
+    showError(err);
+  }
+}
+async function submitBuyerEvidence(taskId) {
+  const argument = await input9({ message: "Your argument / evidence description", validate: (v) => v.length > 10 || "Min 10 chars" });
+  const docUrl = await input9({ message: "Document URL (link to evidence)", validate: (v) => v.length > 0 || "At least one document URL required" });
+  const s = spin("Submitting evidence...");
+  try {
+    await api.post(`/dashboard/tasks/${taskId}/evidence`, {
+      argument,
+      documents: [docUrl]
+    });
+    s.succeed(c.success("Evidence submitted!"));
+    showSuccess("Your evidence has been recorded for arbitration.");
+  } catch (err) {
+    s.fail("Failed to submit evidence");
+    showError(err);
+  }
+}
+var init_dashboard = __esm({
+  "src/commands/dashboard.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/messages.ts
+var messages_exports = {};
+__export(messages_exports, {
+  listConversations: () => listConversations,
+  markConversationRead: () => markConversationRead,
+  searchMessages: () => searchMessages,
+  sendConversationMessage: () => sendConversationMessage,
+  viewConversation: () => viewConversation
+});
+import { input as input10 } from "@inquirer/prompts";
+async function listConversations() {
+  const s = spin("Loading conversations...");
+  try {
+    const res = await api.get("/dashboard/messages");
+    s.stop();
+    if (res.conversations.length === 0) {
+      console.log(c.warn("\n  No conversations.\n"));
+      return;
+    }
+    section(`Conversations (${res.conversations.length})`);
+    const table = createTable(["Task", "With", "Last Message", "Messages", "Updated"]);
+    for (const conv of res.conversations) {
+      const lastContent = conv.lastMessage?.content || "";
+      const preview = lastContent ? lastContent.length > 35 ? lastContent.slice(0, 35) + "..." : lastContent : c.muted("--");
+      table.push([c.bold(conv.title || conv.taskId.slice(0, 8)), c.cool(conv.counterparty?.name || "\u2014"), preview, c.muted(String(conv.messageCount)), formatDate(conv.updatedAt)]);
+    }
+    console.log(table.toString() + "\n");
+  } catch (err) {
+    s.fail("Failed to load conversations");
+    showError(err);
+  }
+}
+async function viewConversation(taskId) {
+  const s = spin("Loading messages...");
+  try {
+    const res = await api.get(`/dashboard/messages/${taskId}`);
+    s.stop();
+    if (res.messages.length === 0) {
+      console.log(c.muted("\n  No messages yet.\n"));
+      return;
+    }
+    section(`Messages \u2014 ${res.task?.title || taskId.slice(0, 8)}`);
+    for (const msg of res.messages) {
+      const sender = msg.senderType === "BUYER" ? c.cool("You") : msg.senderType === "AGENT" ? c.warm(res.counterparty?.name || "Agent") : c.muted("System");
+      console.log(`  ${sender} ${c.dim(formatDate(msg.createdAt))}`);
+      console.log(`  ${msg.content}
+`);
+    }
+    try {
+      await api.post(`/dashboard/messages/${taskId}/read`);
+    } catch {
+    }
+  } catch (err) {
+    s.fail("Failed to load messages");
+    showError(err);
+  }
+}
+async function sendConversationMessage(taskId) {
+  const content = await input10({ message: "Message", validate: (v) => v.length > 0 || "Required" });
+  const s = spin("Sending...");
+  try {
+    await api.post(`/dashboard/messages/${taskId}`, { content });
+    s.succeed(c.success("Message sent!"));
+  } catch (err) {
+    s.fail("Failed to send message");
+    showError(err);
+  }
+}
+async function markConversationRead(taskId) {
+  const s = spin("Marking messages as read...");
+  try {
+    const res = await api.post(`/dashboard/messages/${taskId}/read`, {});
+    s.succeed(c.success("Messages marked as read!"));
+    showSuccess(`${res.marked} message${res.marked !== 1 ? "s" : ""} marked as read.`);
+    console.log();
+  } catch (err) {
+    s.fail("Failed to mark messages as read");
+    showError(err);
+  }
+}
+async function searchMessages(query) {
+  if (!query) {
+    query = await input10({ message: "Search messages", validate: (v) => v.length > 0 || "Required" });
+  }
+  const s = spin(`Searching "${query}"...`);
+  try {
+    const res = await api.get("/dashboard/messages/search", { q: query });
+    s.stop();
+    if (res.results.length === 0) {
+      console.log(c.warn(`
+  No messages matching "${query}"
+`));
+      return;
+    }
+    section(`${res.results.length} results for "${query}"`);
+    for (const r of res.results) {
+      const senderLabel = r.matchSenderType === "BUYER" ? "You" : r.matchSenderType === "AGENT" ? r.counterparty?.name || "Agent" : "System";
+      console.log(`  ${c.warm.bold(r.title || r.taskId.slice(0, 8))} ${c.dim(formatDate(r.matchCreatedAt))}`);
+      console.log(`  ${c.muted(senderLabel + ":")} ${r.matchSnippet}
+`);
+    }
+  } catch (err) {
+    s.fail("Search failed");
+    showError(err);
+  }
+}
+var init_messages = __esm({
+  "src/commands/messages.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/commands/agents.ts
+var agents_exports = {};
+__export(agents_exports, {
+  acceptTask: () => acceptTask,
+  agentStats: () => agentStats,
+  createAgentHireRequest: () => createAgentHireRequest,
+  deleteAgent: () => deleteAgent,
+  deliverTask: () => deliverTask,
+  inbox: () => inbox,
+  listAgentHireRequests: () => listAgentHireRequests,
+  listMyAgents: () => listMyAgents,
+  manageImages: () => manageImages,
+  registerAgent: () => registerAgent,
+  respondAgentHireRequest: () => respondAgentHireRequest,
+  respondToDispute: () => respondToDispute,
+  submitEvidence: () => submitEvidence,
+  updateAgent: () => updateAgent,
+  updateProgress: () => updateProgress,
+  verifyListing: () => verifyListing,
+  viewAgentHireRequest: () => viewAgentHireRequest
+});
+import chalk3 from "chalk";
+import { readFileSync as readFileSync3 } from "fs";
+import { basename, extname } from "path";
+import { input as input11, select as select10, number as numPrompt5, checkbox } from "@inquirer/prompts";
+async function listMyAgents() {
+  const s = spin("Loading your listings...");
+  try {
+    const res = await api.get("/dashboard/agents");
+    s.stop();
+    if (res.agents.length === 0) {
+      console.log(
+        c.warn("\n  You haven't created any listings yet.") + c.muted('\n  Run "g0 listings:create" to create one.\n')
+      );
+      return;
+    }
+    section(`Your Listings (${res.agents.length})`);
+    const table = createTable([
+      "Listing",
+      "Status",
+      "Score",
+      "Rating",
+      "Tasks",
+      "Images",
+      "Earnings"
+    ]);
+    for (const a of res.agents) {
+      const imgCount = a.gallery?.length ?? 0;
+      table.push([
+        c.warm.bold(a.name) + "\n" + c.dim(a.slug) + (a.isVerified ? c.cool(" \u2713") : ""),
+        formatStatus(a.status),
+        formatRepScore(a.stats.reputationScore),
+        a.stats.avgRating > 0 ? formatRating(a.stats.avgRating, a.stats.reviewCount) : c.muted("\u2014"),
+        `${a.stats.tasksCompleted} ${c.dim("done")}
+${c.cool(String(a.stats.activeTasks))} ${c.dim("active")}`,
+        imgCount > 0 ? `${imgCount} ${c.dim("image" + (imgCount !== 1 ? "s" : ""))}` : c.muted("none"),
+        formatPrice(String(a.stats.totalEarnings), a.currency)
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load listings");
+    showError(err);
+  }
+}
+async function registerAgent() {
+  console.log(c.warm.bold("\n  Create a New Listing\n"));
+  const name = await input11({
+    message: "Listing title",
+    validate: (v) => v.length >= 2 ? true : "Name must be at least 2 characters"
+  });
+  const slug = await input11({
+    message: "Listing slug (e.g. my-coding-agent)",
+    default: name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, ""),
+    validate: (v) => /^[a-z0-9-]+$/.test(v) ? true : "Only lowercase letters, numbers, and hyphens"
+  });
+  const tagline = await input11({
+    message: "Listing tagline (short description)",
+    validate: (v) => v.length >= 5 ? true : "At least 5 characters"
+  });
+  const description = await input11({
+    message: "Listing description",
+    validate: (v) => v.length >= 20 ? true : "At least 20 characters"
+  });
+  console.log(chalk3.bold("\nSelect subcategories for your listing:"));
+  const categoryChoices = [
+    "Python",
+    "JavaScript",
+    "TypeScript",
+    "React",
+    "Next.js",
+    "Vue",
+    "Node.js",
+    "Django",
+    "Flask",
+    "REST APIs",
+    "GraphQL",
+    "AI/ML",
+    "LLM Fine-tuning",
+    "Data Analysis",
+    "Web Scraping",
+    "SEO",
+    "Content Writing",
+    "Digital Marketing",
+    "UI/UX Design",
+    "Logo Design",
+    "Video Editing",
+    "Smart Contracts",
+    "Solidity",
+    "DevOps",
+    "Docker",
+    "AWS",
+    "Customer Support",
+    "Sales Automation",
+    "Cold Calling"
+  ].map((s2) => ({ name: s2, value: s2 }));
+  const selectedSubs = await checkbox({
+    message: "Pick subcategories (space to select, enter to confirm)",
+    choices: categoryChoices
+  });
+  if (selectedSubs.length === 0) {
+    showError(new Error("At least one subcategory is required"));
+    return;
+  }
+  const pricingModel = await select10({
+    message: "Pricing model",
+    choices: [
+      { name: "Per Task", value: "PER_TASK" },
+      { name: "Hourly", value: "HOURLY" },
+      { name: "Per Token", value: "PER_TOKEN" },
+      { name: "Subscription", value: "SUBSCRIPTION" },
+      { name: "Custom", value: "CUSTOM" }
+    ]
+  });
+  const basePrice = await numPrompt5({
+    message: "Base price (USDC)",
+    default: 5,
+    min: 0.01
+  });
+  if (basePrice && basePrice > 0) {
+    const bp = basePrice;
+    const pFee = bp * 0.1;
+    const fFee = 0.5;
+    const receive = bp - pFee - fFee;
+    console.log("");
+    console.log(c.warm.bold("  \u{1F4B0} Fee Breakdown:"));
+    console.log(`     List Price:         ${c.bold("$" + bp.toFixed(2))}`);
+    console.log(`     Platform Fee (10%): ${chalk3.red("-$" + pFee.toFixed(2))}`);
+    console.log(`     Facilitation Fee:   ${chalk3.red("-$0.50")}`);
+    console.log(c.dim("     \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(`     You Receive:        ${c.success.bold("$" + receive.toFixed(2))}`);
+    console.log("");
+    console.log(c.muted(`  \u2139 Buyers pay $${bp.toFixed(2)} (no added fees \u2014 platform fee waived during launch)`));
+    console.log("");
+  }
+  const webhookUrl = await input11({
+    message: "Webhook URL (for receiving tasks)",
+    validate: (v) => v.startsWith("http") ? true : "Must be a valid URL"
+  });
+  const apiEndpoint = await input11({
+    message: "API endpoint (optional)"
+  });
+  const s = spin("Creating listing...");
+  try {
+    const res = await api.post("/agents/register", {
+      name,
+      slug,
+      tagline,
+      description,
+      subcategories: selectedSubs,
+      tags: selectedSubs,
+      pricingModel,
+      basePrice: basePrice ?? 5,
+      executionMode: "REMOTE",
+      webhookUrl: webhookUrl || void 0,
+      apiEndpoint: apiEndpoint || void 0
+    });
+    s.succeed(c.success("Listing created!"));
+    showSuccess(
+      `${c.warm.bold(res.listing.name)} is live at ${c.cool(`/marketplace/${res.listing.slug}`)}`
+    );
+    console.log(c.muted(`  Listing ID: ${res.listing.id}
+`));
+    if (res.fees) {
+      console.log(c.warm.bold("  Fee Summary:"));
+      console.log(`     Platform Fee: ${res.fees.platformFeePercent}% of base price`);
+      console.log(`     Facilitation Fee: $${res.fees.facilitationFee.toFixed(2)} per task`);
+      console.log(`     You Receive: ${c.success.bold("$" + res.fees.youReceive.toFixed(2))} per task`);
+      console.log(`     Buyer Fees: ${c.cool(res.fees.buyerFees)}`);
+      console.log("");
+    }
+    if (res.verified) {
+      showSuccess("Listing created and verified! Your agent responded to the heartbeat check.");
+    } else {
+      console.log(chalk3.yellow("\n\u26A0 Listing created but NOT verified."));
+      console.log(chalk3.dim("  Your agent did not respond to the heartbeat check."));
+      console.log(chalk3.dim("  Check your webhook/API endpoint configuration."));
+    }
+    console.log(c.cool(`
+  Upload images with: g0 listings:images ${res.listing?.id ?? "<id>"}
+`));
+  } catch (err) {
+    s.fail("Failed to create listing");
+    showError(err);
+  }
+}
+async function agentStats(agentId) {
+  const s = spin("Loading stats...");
+  try {
+    if (agentId) {
+      const res = await api.get(`/agents/${agentId}`);
+      s.stop();
+      printAgentStats(res.agent);
+    } else {
+      const [statsRes, agentsRes] = await Promise.all([
+        api.get("/dashboard/stats"),
+        api.get("/dashboard/agents")
+      ]);
+      s.stop();
+      section("Dashboard Overview");
+      if (agentsRes.agents) {
+        for (const a of agentsRes.agents) {
+          const agent = {
+            ...a,
+            basePrice: String(a.basePrice),
+            description: "",
+            tags: [],
+            tasksCompleted: a.stats.tasksCompleted,
+            totalEarnings: String(a.stats.totalEarnings),
+            avgRating: a.stats.avgRating,
+            reviewCount: a.stats.reviewCount,
+            reputationScore: a.stats.reputationScore,
+            successRate: a.stats.successRate,
+            activeTasks: a.stats.activeTasks,
+            maxConcurrent: a.stats.maxConcurrent
+          };
+          printAgentStats(agent);
+        }
+      }
+    }
+  } catch (err) {
+    s.fail("Failed to load stats");
+    showError(err);
+  }
+}
+function printAgentStats(agent) {
+  infoBox(`${agent.name} \u2014 Listing Stats`, [
+    `${c.muted("Status:")}        ${formatStatus(agent.status)}`,
+    `${c.muted("Rep Score:")}     ${formatRepScore(agent.reputationScore)}`,
+    `${c.muted("Rating:")}        ${formatRating(agent.avgRating, agent.reviewCount)}`,
+    `${c.muted("Tasks Done:")}    ${c.bold(String(agent.tasksCompleted))}`,
+    `${c.muted("Active Tasks:")}  ${c.cool(String(agent.activeTasks))} / ${agent.maxConcurrent}`,
+    `${c.muted("Success Rate:")}  ${agent.successRate.toFixed(1)}%`,
+    `${c.muted("Total Earned:")}  ${c.success.bold("$" + parseFloat(agent.totalEarnings).toFixed(2))} ${c.dim(agent.currency)}`,
+    `${c.muted("Price:")}         ${formatPrice(agent.basePrice, agent.currency)} ${c.dim(`(${agent.pricingModel.replace(/_/g, " ").toLowerCase()})`)}`,
+    `${c.muted("Since:")}         ${formatDate(agent.createdAt)}`
+  ]);
+  console.log();
+}
+async function inbox(agentId) {
+  const s = spin("Loading inbox...");
+  try {
+    const res = await api.get(`/agents/${agentId}/inbox`);
+    s.stop();
+    if (res.tasks.length === 0) {
+      console.log(c.muted("\n  No pending tasks in inbox.\n"));
+      return;
+    }
+    section(`Listing Inbox (${res.tasks.length} tasks)`);
+    const table = createTable([
+      "ID",
+      "Title",
+      "Buyer",
+      "Budget",
+      "Priority",
+      "Status",
+      "Received"
+    ]);
+    for (const t of res.tasks) {
+      table.push([
+        c.dim(t.id.slice(0, 8)),
+        c.bold(t.title),
+        t.buyer?.name || c.muted("\u2014"),
+        formatPrice(t.budget, t.currency),
+        t.priority === "URGENT" ? c.err.bold(t.priority) : t.priority === "HIGH" ? c.warn(t.priority) : c.muted(t.priority),
+        formatStatus(t.status),
+        formatDate(t.createdAt)
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load inbox");
+    showError(err);
+  }
+}
+async function verifyListing(agentId) {
+  const s = spin("Sending heartbeat verification...");
+  try {
+    const data = await api.post(`/agents/${agentId}/verify`);
+    s.stop();
+    if (data.verified) {
+      showSuccess(data.message);
+    } else {
+      console.log(chalk3.yellow(`
+\u26A0 ${data.message}`));
+    }
+  } catch (err) {
+    s.stop();
+    showError(err);
+  }
+}
+async function acceptTask(agentId, taskId) {
+  const price = await numPrompt5({
+    message: "Your proposed price (USDC)",
+    min: 0.01
+  });
+  const estimatedMs = await numPrompt5({
+    message: "Estimated time (minutes)",
+    default: 60,
+    min: 1
+  });
+  const s = spin("Accepting task...");
+  try {
+    await api.post(`/agents/${agentId}/propose`, {
+      taskId,
+      proposedPrice: price,
+      estimatedMs: (estimatedMs ?? 60) * 6e4,
+      message: "Task accepted via g0 CLI"
+    });
+    s.succeed(c.success("Task accepted!"));
+    showSuccess(`You've accepted task ${c.dim(taskId.slice(0, 8))}`);
+  } catch (err) {
+    s.fail("Failed to accept task");
+    showError(err);
+  }
+}
+async function updateProgress(taskId) {
+  const progress = await numPrompt5({
+    message: "Progress (%)",
+    min: 0,
+    max: 100
+  });
+  const message = await input11({
+    message: "Progress update message"
+  });
+  const s = spin("Updating...");
+  try {
+    await api.patch(`/tasks/${taskId}/progress`, {
+      progress: progress ?? 0,
+      progressMessage: message || void 0
+    });
+    s.succeed(c.success("Progress updated!"));
+  } catch (err) {
+    s.fail("Failed to update progress");
+    showError(err);
+  }
+}
+async function deliverTask(agentId, taskId) {
+  const summary = await input11({
+    message: "Delivery summary",
+    validate: (v) => v.length > 0 ? true : "Summary required"
+  });
+  const completionMessage = await input11({
+    message: "Completion message to buyer (optional)"
+  });
+  const s = spin("Delivering task...");
+  try {
+    const body = { summary };
+    if (completionMessage) body.completionMessage = completionMessage;
+    const res = await api.post(`/agents/${agentId}/tasks/${taskId}/deliver`, body);
+    s.succeed(c.success("Task delivered!"));
+    showSuccess("The buyer will review your delivery.");
+    if (res.task?.autoConfirmAt) {
+      console.log(c.muted(`  Auto-confirms: ${formatDate(res.task.autoConfirmAt)}`));
+    }
+    console.log();
+  } catch (err) {
+    s.fail("Failed to deliver task");
+    showError(err);
+  }
+}
+async function respondToDispute(agentId, taskId) {
+  const action = await select10({
+    message: "How do you want to respond?",
+    choices: [
+      { name: "Accept & Redeliver \u2014 fix and redeliver the work", value: "accept" },
+      { name: "Reject \u2014 escalate to platform arbitration", value: "reject" }
+    ]
+  });
+  let message = "";
+  if (action === "accept") {
+    message = await input11({ message: "Message to buyer (what you'll fix)", validate: (v) => v.length > 0 ? true : "Required" });
+  } else {
+    message = await input11({ message: "Reason for rejecting the dispute", validate: (v) => v.length > 0 ? true : "Required" });
+  }
+  const s = spin("Submitting response...");
+  try {
+    await api.post(`/agents/${agentId}/tasks/${taskId}/dispute`, { action, message });
+    s.succeed(c.success("Dispute response submitted!"));
+    if (action === "accept") {
+      showSuccess("Task moved back to EXECUTING. Redeliver when ready.");
+    } else {
+      showSuccess("Escalated to arbitration. Submit evidence to support your case.");
+      console.log(c.muted(`  Submit evidence: g0 agents:evidence ${agentId} ${taskId}
+`));
+    }
+  } catch (err) {
+    s.fail("Failed to respond to dispute");
+    showError(err);
+  }
+}
+async function submitEvidence(agentId, taskId) {
+  const description = await input11({ message: "Evidence description", validate: (v) => v.length > 5 ? true : "Min 5 chars" });
+  const details = await input11({ message: "Supporting details (optional)" });
+  const s = spin("Submitting evidence...");
+  try {
+    await api.post(`/agents/${agentId}/tasks/${taskId}/evidence`, {
+      description,
+      details: details || void 0
+    });
+    s.succeed(c.success("Evidence submitted!"));
+    showSuccess("Your evidence has been recorded for arbitration review.");
+  } catch (err) {
+    s.fail("Failed to submit evidence");
+    showError(err);
+  }
+}
+async function updateAgent(agentId) {
+  const s = spin("Loading current listing...");
+  let agent;
+  try {
+    const res = await api.get(`/agents/${agentId}`);
+    agent = res.agent;
+    s.stop();
+  } catch (err) {
+    s.fail("Failed to load listing");
+    showError(err);
+    return;
+  }
+  console.log(c.warm.bold(`
+  Update: ${agent.name}
+`));
+  console.log(c.muted("  Press Enter to keep current value.\n"));
+  const name = await input11({ message: "Name", default: agent.name });
+  const tagline = await input11({ message: "Tagline", default: agent.tagline });
+  const description = await input11({ message: "Description", default: agent.description });
+  const basePrice = await numPrompt5({ message: "Base price (USDC)", default: parseFloat(agent.basePrice), min: 0.01 });
+  const updates = {};
+  if (name !== agent.name) updates.name = name;
+  if (tagline !== agent.tagline) updates.tagline = tagline;
+  if (description !== agent.description) updates.description = description;
+  if (basePrice !== void 0 && basePrice !== parseFloat(agent.basePrice)) updates.basePrice = basePrice;
+  if (Object.keys(updates).length === 0) {
+    console.log(c.muted("\n  No changes made.\n"));
+    return;
+  }
+  const s2 = spin("Updating listing...");
+  try {
+    await api.patch(`/agents/${agentId}`, updates);
+    s2.succeed(c.success("Listing updated!"));
+  } catch (err) {
+    s2.fail("Failed to update listing");
+    showError(err);
+  }
+}
+async function deleteAgent(agentId) {
+  const { confirm: confirm4 } = await import("@inquirer/prompts");
+  const yes = await confirm4({ message: "Are you sure? This permanently deletes the listing and all data.", default: false });
+  if (!yes) {
+    console.log(c.muted("\n  Cancelled.\n"));
+    return;
+  }
+  const s = spin("Deleting listing...");
+  try {
+    await api.delete(`/agents/${agentId}`);
+    s.succeed(c.success("Listing deleted."));
+  } catch (err) {
+    s.fail("Failed to delete listing");
+    showError(err);
+  }
+}
+async function manageImages(agentId) {
+  const s = spin("Loading listing images...");
+  let current;
+  try {
+    current = await api.get(`/agents/${agentId}/images`);
+    s.stop();
+  } catch (err) {
+    s.fail("Failed to load images");
+    showError(err);
+    return;
+  }
+  const showStatus = (data) => {
+    const count = data.gallery.length;
+    console.log();
+    section(`Listing Images (${count}/5)`);
+    if (count === 0) {
+      console.log(c.muted("  No images uploaded yet.\n"));
+    } else {
+      for (let i = 0; i < data.gallery.length; i++) {
+        const isPrimary = data.coverImage === data.gallery[i];
+        const label = isPrimary ? c.cool(" [PRIMARY]") : "";
+        console.log(`  ${c.dim(`[${i}]`)} ${c.bold(basename(data.gallery[i]))}${label}`);
+      }
+      console.log();
+    }
+  };
+  showStatus(current);
+  let running = true;
+  while (running) {
+    const action = await select10({
+      message: "What would you like to do?",
+      choices: [
+        { name: "Upload image", value: "upload" },
+        { name: "Remove image", value: "remove" },
+        { name: "Set primary image", value: "primary" },
+        { name: "Back", value: "back" }
+      ]
+    });
+    switch (action) {
+      case "upload": {
+        if (current.gallery.length >= 5) {
+          console.log(c.warn("\n  Maximum 5 images reached. Remove one first.\n"));
+          break;
+        }
+        const filePath = await input11({
+          message: "Path to image file",
+          validate: (v) => {
+            if (!v.trim()) return "File path required";
+            const ext2 = extname(v).toLowerCase();
+            if (!SUPPORTED_IMAGE_FORMATS.includes(ext2)) {
+              return `Unsupported format. Use: ${SUPPORTED_IMAGE_FORMATS.join(", ")}`;
+            }
+            return true;
+          }
+        });
+        let fileBuffer;
+        try {
+          fileBuffer = readFileSync3(filePath.trim());
+        } catch {
+          console.log(c.err("\n  Could not read file. Check the path and try again.\n"));
+          break;
+        }
+        if (fileBuffer.length > MAX_IMAGE_SIZE) {
+          console.log(c.err(`
+  File too large (${(fileBuffer.length / 1024 / 1024).toFixed(1)}MB). Max is 5MB.
+`));
+          break;
+        }
+        const ext = extname(filePath.trim()).toLowerCase();
+        const mimeMap = {
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".png": "image/png",
+          ".webp": "image/webp",
+          ".gif": "image/gif"
+        };
+        const mimeType = mimeMap[ext] ?? "application/octet-stream";
+        const base64Data = fileBuffer.toString("base64");
+        const us = spin("Uploading image...");
+        try {
+          current = await api.post(`/agents/${agentId}/images`, {
+            image: base64Data,
+            filename: basename(filePath.trim()),
+            mimeType
+          });
+          us.succeed(c.success("Image uploaded!"));
+          showStatus(current);
+        } catch (err) {
+          us.fail("Failed to upload image");
+          showError(err);
+        }
+        break;
+      }
+      case "remove": {
+        if (current.gallery.length === 0) {
+          console.log(c.muted("\n  No images to remove.\n"));
+          break;
+        }
+        const removeIdx = await select10({
+          message: "Which image to remove?",
+          choices: current.gallery.map((url, i) => {
+            const isPrimary = current.coverImage === url;
+            return {
+              name: `[${i}] ${basename(url)}${isPrimary ? " (primary)" : ""}`,
+              value: i
+            };
+          })
+        });
+        const ds = spin("Removing image...");
+        try {
+          const { getApiKey: getApiKey2, getApiUrl: getApiUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const baseUrl = getApiUrl2();
+          const apiKey = getApiKey2();
+          const res = await fetch(`${baseUrl}/api/v1/agents/${agentId}/images`, {
+            method: "DELETE",
+            headers: {
+              "Content-Type": "application/json",
+              "User-Agent": "@g0hub/cli/1.0.0",
+              Authorization: `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({ index: removeIdx })
+          });
+          if (!res.ok) {
+            const errBody = await res.json().catch(() => ({}));
+            throw new Error(errBody.error ?? `HTTP ${res.status}`);
+          }
+          current = await res.json();
+          ds.succeed(c.success("Image removed!"));
+          showStatus(current);
+        } catch (err) {
+          ds.fail("Failed to remove image");
+          showError(err);
+        }
+        break;
+      }
+      case "primary": {
+        if (current.gallery.length === 0) {
+          console.log(c.muted("\n  No images to set as primary.\n"));
+          break;
+        }
+        const primaryIdx = await select10({
+          message: "Which image to set as primary?",
+          choices: current.gallery.map((url, i) => {
+            const isPrimary = current.coverImage === url;
+            return {
+              name: `[${i}] ${basename(url)}${isPrimary ? " (current primary)" : ""}`,
+              value: i
+            };
+          })
+        });
+        const ps = spin("Setting primary image...");
+        try {
+          current = await api.patch(`/agents/${agentId}/images`, {
+            primaryIndex: primaryIdx
+          });
+          ps.succeed(c.success("Primary image updated!"));
+          showStatus(current);
+        } catch (err) {
+          ps.fail("Failed to set primary image");
+          showError(err);
+        }
+        break;
+      }
+      case "back":
+        running = false;
+        break;
+    }
+  }
+}
+async function listAgentHireRequests(agentId) {
+  const s = spin("Loading hire requests...");
+  try {
+    const res = await api.get(`/agents/${agentId}/hire-requests`);
+    s.stop();
+    if (res.hireRequests.length === 0) {
+      console.log(c.muted("\n  No hire requests for this agent.\n"));
+      return;
+    }
+    section(`Agent Hire Requests (${res.hireRequests.length})`);
+    const table = createTable(["ID", "Title", "Buyer", "Price", "From", "Status", "Date"]);
+    for (const r of res.hireRequests) {
+      table.push([
+        c.dim(r.id.slice(0, 8)),
+        c.bold(r.title),
+        r.buyer?.name || c.muted("\u2014"),
+        formatPrice(r.price, r.currency),
+        r.initiatedBy === "BUYER" ? c.cool("Buyer") : c.warm("Agent"),
+        formatStatus(r.status),
+        formatDate(r.createdAt)
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load hire requests");
+    showError(err);
+  }
+}
+async function createAgentHireRequest(agentId) {
+  const { number: numPrompt6 } = await import("@inquirer/prompts");
+  const taskId = await input11({
+    message: "Task ID (existing conversation)",
+    validate: (v) => v.length > 0 || "Required"
+  });
+  const title = await input11({
+    message: "Hire request title",
+    validate: (v) => v.length > 0 || "Required"
+  });
+  const description = await input11({
+    message: "Description of the work",
+    validate: (v) => v.length > 0 || "Required"
+  });
+  const deliverableItem = await input11({
+    message: "Primary deliverable",
+    validate: (v) => v.length > 0 || "Required"
+  });
+  const price = await numPrompt6({
+    message: "Price (USDC)",
+    min: 0.01,
+    default: 10
+  });
+  const estimatedDays = await numPrompt6({
+    message: "Estimated days to complete (optional)",
+    min: 1
+  });
+  const s = spin("Creating hire request...");
+  try {
+    const body = {
+      taskId,
+      title,
+      description,
+      deliverables: [{ item: deliverableItem }],
+      price: price ?? 10
+    };
+    if (estimatedDays) body.estimatedDays = estimatedDays;
+    const res = await api.post(`/agents/${agentId}/hire-requests`, body);
+    s.succeed(c.success("Hire request created!"));
+    showSuccess(`Request ${c.dim(res.hireRequest.id.slice(0, 8))} sent to buyer.`);
+    console.log();
+  } catch (err) {
+    s.fail("Failed to create hire request");
+    showError(err);
+  }
+}
+async function viewAgentHireRequest(agentId, requestId) {
+  const s = spin("Loading hire request...");
+  try {
+    const res = await api.get(`/agents/${agentId}/hire-requests/${requestId}`);
+    const r = res.hireRequest;
+    s.stop();
+    infoBox(`Hire Request: ${r.title}`, [
+      `${c.muted("ID:")}          ${c.dim(r.id)}`,
+      `${c.muted("Buyer:")}       ${r.buyer?.name || c.muted("\u2014")}`,
+      `${c.muted("Price:")}       ${formatPrice(r.price, r.currency)}`,
+      `${c.muted("Status:")}      ${formatStatus(r.status)}`,
+      `${c.muted("Initiated By:")} ${r.initiatedBy === "BUYER" ? c.cool("Buyer") : c.warm("Agent")}`,
+      ...r.counterPrice ? [`${c.muted("Counter:")}     ${formatPrice(r.counterPrice, r.currency)}`] : [],
+      ...r.counterNote ? [`${c.muted("Counter Note:")} ${r.counterNote}`] : [],
+      ...r.responseNote ? [`${c.muted("Response:")}    ${r.responseNote}`] : [],
+      ...r.estimatedDays ? [`${c.muted("Est. Days:")}   ${r.estimatedDays}`] : [],
+      `${c.muted("Created:")}     ${formatDate(r.createdAt)}`,
+      ...r.respondedAt ? [`${c.muted("Responded:")}   ${formatDate(r.respondedAt)}`] : [],
+      ...r.task ? [`${c.muted("Task:")}        ${c.dim(r.task.id.slice(0, 8))} \u2014 ${formatStatus(r.task.status)}`] : []
+    ]);
+    if (r.description) {
+      console.log(c.muted("\n  Description:"));
+      console.log("  " + r.description + "\n");
+    }
+  } catch (err) {
+    s.fail("Failed to load hire request");
+    showError(err);
+  }
+}
+async function respondAgentHireRequest(agentId, requestId) {
+  const { number: numPrompt6 } = await import("@inquirer/prompts");
+  const action = await select10({
+    message: "How do you want to respond?",
+    choices: [
+      { name: "Accept \u2014 agree to the hire request", value: "accept" },
+      { name: "Reject \u2014 decline the hire request", value: "reject" },
+      { name: "Negotiate \u2014 propose a counter price", value: "negotiate" }
+    ]
+  });
+  let note;
+  let counterPrice;
+  if (action === "negotiate") {
+    counterPrice = await numPrompt6({ message: "Counter price (USDC)", min: 0.01 }) ?? void 0;
+    if (!counterPrice) {
+      console.log(c.err("\n  Counter price is required for negotiation.\n"));
+      return;
+    }
+  }
+  note = await input11({ message: "Note (optional)" }) || void 0;
+  const s = spin("Sending response...");
+  try {
+    const body = { action };
+    if (note) body.note = note;
+    if (counterPrice) body.counterPrice = counterPrice;
+    const res = await api.post(
+      `/agents/${agentId}/hire-requests/${requestId}`,
+      body
+    );
+    s.succeed(c.success("Response sent!"));
+    if (action === "accept") {
+      showSuccess("Hire request accepted. Buyer will be notified to complete payment.");
+    } else if (action === "reject") {
+      showSuccess("Hire request declined.");
+    } else {
+      showSuccess(`Counter-offer of ${formatPrice(counterPrice)} sent.`);
+    }
+    console.log();
+  } catch (err) {
+    s.fail("Failed to respond");
+    showError(err);
+  }
+}
+var SUPPORTED_IMAGE_FORMATS, MAX_IMAGE_SIZE;
+var init_agents = __esm({
+  "src/commands/agents.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+    SUPPORTED_IMAGE_FORMATS = [".jpg", ".jpeg", ".png", ".webp", ".gif"];
+    MAX_IMAGE_SIZE = 5 * 1024 * 1024;
+  }
+});
+
+// src/commands/keys.ts
+var keys_exports = {};
+__export(keys_exports, {
+  createKey: () => createKey,
+  listKeys: () => listKeys,
+  revokeKey: () => revokeKey
+});
+import { input as input12, select as select11, confirm as confirm3 } from "@inquirer/prompts";
+async function listKeys() {
+  const s = spin("Loading API keys...");
+  try {
+    const res = await api.get("/user/api-keys");
+    s.stop();
+    if (res.apiKeys.length === 0) {
+      console.log(
+        c.warn("\n  No API keys.") + c.muted(' Run "g0 keys:create" to generate one.\n')
+      );
+      return;
+    }
+    section(`API Keys (${res.apiKeys.length})`);
+    const table = createTable([
+      "Name",
+      "Prefix",
+      "Status",
+      "Permissions",
+      "Requests",
+      "Last Used"
+    ]);
+    for (const key of res.apiKeys) {
+      table.push([
+        c.bold(key.name),
+        c.dim(key.keyPrefix + "..."),
+        key.isActive ? c.success("active") : c.err("revoked"),
+        key.permissions.length > 0 ? key.permissions.join(", ") : c.muted("all"),
+        String(key.requestCount),
+        key.lastUsedAt ? formatDate(key.lastUsedAt) : c.muted("never")
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    s.fail("Failed to load keys");
+    showError(err);
+  }
+}
+async function createKey() {
+  const name = await input12({
+    message: "Key name (e.g. 'production', 'my-bot')",
+    validate: (v) => v.length > 0 ? true : "Name required"
+  });
+  const permissions = await select11({
+    message: "Permissions",
+    choices: [
+      { name: "Full access (all permissions)", value: "all" },
+      { name: "Read only (marketplace, agents)", value: "read" },
+      { name: "Agent management only", value: "agent" },
+      { name: "Task management only", value: "task" }
+    ]
+  });
+  const permList = permissions === "all" ? ["tasks:read", "tasks:write", "agents:read", "agents:write", "billing:read"] : permissions === "read" ? ["tasks:read", "agents:read", "billing:read"] : permissions === "agent" ? ["agents:read", "agents:write"] : ["tasks:read", "tasks:write"];
+  const s = spin("Creating API key...");
+  try {
+    const res = await api.post(
+      "/user/api-keys",
+      { name, permissions: permList }
+    );
+    s.succeed(c.success("API key created!"));
+    console.log();
+    console.log(c.warn.bold("  \u26A0  Save this key \u2014 it won't be shown again:\n"));
+    console.log("  " + c.warm.bold(res.key));
+    console.log();
+    console.log(c.muted("  Use with: g0 auth:key " + res.key));
+    console.log(c.muted("  Or set:   Authorization: Bearer " + res.key));
+    console.log();
+  } catch (err) {
+    s.fail("Failed to create key");
+    showError(err);
+  }
+}
+async function revokeKey(keyId) {
+  if (!keyId) {
+    const s = spin("Loading keys...");
+    try {
+      const res = await api.get("/user/api-keys");
+      s.stop();
+      const activeKeys = res.apiKeys.filter((k) => k.isActive);
+      if (activeKeys.length === 0) {
+        console.log(c.muted("\n  No active keys to revoke.\n"));
+        return;
+      }
+      keyId = await select11({
+        message: "Select key to revoke",
+        choices: activeKeys.map((k) => ({
+          name: `${k.name} (${k.keyPrefix}...)`,
+          value: k.id
+        }))
+      });
+    } catch (err) {
+      s.fail("Failed to load keys");
+      showError(err);
+      return;
+    }
+  }
+  const yes = await confirm3({
+    message: "Are you sure? This cannot be undone.",
+    default: false
+  });
+  if (!yes) {
+    console.log(c.muted("\n  Cancelled.\n"));
+    return;
+  }
+  const s2 = spin("Revoking key...");
+  try {
+    await api.delete(`/user/api-keys/${keyId}`);
+    s2.succeed(c.success("Key revoked!"));
+  } catch (err) {
+    s2.fail("Failed to revoke key");
+    showError(err);
+  }
+}
+var init_keys = __esm({
+  "src/commands/keys.ts"() {
+    "use strict";
+    init_api();
+    init_ui();
+  }
+});
+
+// src/index.ts
+init_ui();
+init_config();
+import { Command } from "commander";
+var program = new Command();
+program.name("g0").description(
+  "CLI for the g0 AI Agent Marketplace \u2014 hire agents, manage tasks, deploy services, and earn money."
+).version("0.1.0");
+program.command("login").description("Sign in to your g0 account").action(async () => {
+  const { login: login2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await login2();
+});
+program.command("register").description("Create a new g0 account").action(async () => {
+  const { register: register2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await register2();
+});
+program.command("logout").description("Sign out and clear credentials").action(async () => {
+  const { logout: logout2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await logout2();
+});
+program.command("whoami").description("Show current user profile and balance").action(async () => {
+  const { whoami: whoami2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await whoami2();
+});
+program.command("auth:key [key]").description("Authenticate with an API key").action(async (key) => {
+  const { setApiKey: setApiKey2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await setApiKey2(key || "");
+});
+program.command("forgot-password").description("Request a password reset email").action(async () => {
+  const { forgotPassword: forgotPassword2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await forgotPassword2();
+});
+program.command("reset-password").description("Reset your password using a token from email").action(async () => {
+  const { resetPassword: resetPassword2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await resetPassword2();
+});
+program.command("resend-verification").description("Resend account verification email").action(async () => {
+  const { resendVerification: resendVerification2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await resendVerification2();
+});
+program.command("password").description("Change your account password").action(async () => {
+  requireAuth2();
+  const { changePassword: changePassword2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await changePassword2();
+});
+program.command("profile").description("View your profile").action(async () => {
+  requireAuth2();
+  const { viewProfile: viewProfile2 } = await Promise.resolve().then(() => (init_profile(), profile_exports));
+  await viewProfile2();
+});
+program.command("profile:update").description("Update your profile (name, bio, overview)").action(async () => {
+  requireAuth2();
+  const { updateProfile: updateProfile2 } = await Promise.resolve().then(() => (init_profile(), profile_exports));
+  await updateProfile2();
+});
+program.command("wallet").description("View your wallet balance, escrow, and earnings").action(async () => {
+  requireAuth2();
+  const { getWallet: getWallet2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
+  await getWallet2();
+});
+program.command("browse").description("Browse the agent marketplace interactively").action(async () => {
+  const { browse: browse2 } = await Promise.resolve().then(() => (init_marketplace(), marketplace_exports));
+  await browse2();
+});
+program.command("search [query]").description("Search for agents by name, skill, or category").action(async (query) => {
+  const { search: search2 } = await Promise.resolve().then(() => (init_marketplace(), marketplace_exports));
+  await search2(query);
+});
+program.command("agent <slug>").description("View agent details (skills, rating, pricing)").action(async (slug) => {
+  const { viewAgent: viewAgent2 } = await Promise.resolve().then(() => (init_marketplace(), marketplace_exports));
+  await viewAgent2(slug);
+});
+program.command("hire [agent-slug]").description("Hire an agent \u2014 create a new task with interactive prompts").action(async (agentSlug) => {
+  requireAuth2();
+  const { hire: hire2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await hire2(agentSlug);
+});
+program.command("tasks").description("List your tasks with optional status filter").option("-s, --status <status>", "Filter: MATCHING, EXECUTING, DELIVERED, COMPLETED, DISPUTED, CANCELLED").option("-l, --limit <n>", "Max results", "20").action(async (opts) => {
+  requireAuth2();
+  const { listTasks: listTasks2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await listTasks2(opts);
+});
+program.command("task <id>").description("View task details, messages, and delivery status").action(async (id) => {
+  requireAuth2();
+  const { viewTask: viewTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await viewTask2(id);
+});
+program.command("message <task-id>").description("Send a message on a task thread").action(async (taskId) => {
+  requireAuth2();
+  const { sendMessage: sendMessage2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await sendMessage2(taskId);
+});
+program.command("review <task-id>").description("Leave a star rating and review for a completed task").action(async (taskId) => {
+  requireAuth2();
+  const { review: review2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await review2(taskId);
+});
+program.command("order").description("Create a direct-hire order for an agent").action(async () => {
+  requireAuth2();
+  const { createOrder: createOrder2 } = await Promise.resolve().then(() => (init_orders(), orders_exports));
+  await createOrder2();
+});
+program.command("orders").description("List your orders").action(async () => {
+  requireAuth2();
+  const { listOrders: listOrders2 } = await Promise.resolve().then(() => (init_orders(), orders_exports));
+  await listOrders2();
+});
+program.command("jobs").description("List your posted jobs").action(async () => {
+  requireAuth2();
+  const { listJobs: listJobs2 } = await Promise.resolve().then(() => (init_jobs(), jobs_exports));
+  await listJobs2();
+});
+program.command("jobs:create").description("Post a new job for agents to bid on").action(async () => {
+  requireAuth2();
+  const { createJob: createJob2 } = await Promise.resolve().then(() => (init_jobs(), jobs_exports));
+  await createJob2();
+});
+program.command("jobs:proposals <task-id>").description("View proposals submitted for a job").action(async (taskId) => {
+  requireAuth2();
+  const { listJobProposals: listJobProposals2 } = await Promise.resolve().then(() => (init_jobs(), jobs_exports));
+  await listJobProposals2(taskId);
+});
+program.command("jobs:accept <task-id>").description("Accept a proposal and create a task from a job").action(async (taskId) => {
+  requireAuth2();
+  const { acceptJobProposal: acceptJobProposal2 } = await Promise.resolve().then(() => (init_jobs(), jobs_exports));
+  await acceptJobProposal2(taskId);
+});
+program.command("hire-request").description("Send a hire request to an agent").action(async () => {
+  requireAuth2();
+  const { createHireRequest: createHireRequest2 } = await Promise.resolve().then(() => (init_hire(), hire_exports));
+  await createHireRequest2();
+});
+program.command("hire-requests").description("List your hire requests").action(async () => {
+  requireAuth2();
+  const { listHireRequests: listHireRequests2 } = await Promise.resolve().then(() => (init_hire(), hire_exports));
+  await listHireRequests2();
+});
+program.command("hire-requests:view <request-id>").description("View hire request details and agent response").action(async (requestId) => {
+  requireAuth2();
+  const { viewHireRequest: viewHireRequest2 } = await Promise.resolve().then(() => (init_hire(), hire_exports));
+  await viewHireRequest2(requestId);
+});
+program.command("hire-requests:pay <request-id>").description("Pay for an accepted hire request (funds escrow)").action(async (requestId) => {
+  requireAuth2();
+  const { payHireRequest: payHireRequest2 } = await Promise.resolve().then(() => (init_hire(), hire_exports));
+  await payHireRequest2(requestId);
+});
+program.command("inquiry <agent-slug>").description("Start a pre-sale inquiry with an agent owner").action(async (agentSlug) => {
+  requireAuth2();
+  const { createInquiry: createInquiry2 } = await Promise.resolve().then(() => (init_inquiries(), inquiries_exports));
+  await createInquiry2();
+});
+program.command("inquiries").description("List your inquiry conversations").action(async () => {
+  requireAuth2();
+  const { listInquiries: listInquiries2 } = await Promise.resolve().then(() => (init_inquiries(), inquiries_exports));
+  await listInquiries2();
+});
+program.command("inquiries:view <inquiry-id>").description("View inquiry messages").action(async (inquiryId) => {
+  requireAuth2();
+  const { viewInquiry: viewInquiry2 } = await Promise.resolve().then(() => (init_inquiries(), inquiries_exports));
+  await viewInquiry2(inquiryId);
+});
+program.command("inquiries:message <inquiry-id>").description("Send a message in an inquiry").action(async (inquiryId) => {
+  requireAuth2();
+  const { sendInquiryMessage: sendInquiryMessage2 } = await Promise.resolve().then(() => (init_inquiries(), inquiries_exports));
+  await sendInquiryMessage2(inquiryId);
+});
+program.command("inquiries:hire <inquiry-id>").description("Convert an inquiry into a paid task").action(async (inquiryId) => {
+  requireAuth2();
+  const { convertInquiryToTask: convertInquiryToTask2 } = await Promise.resolve().then(() => (init_inquiries(), inquiries_exports));
+  await convertInquiryToTask2(inquiryId);
+});
+program.command("dashboard").description("View your dashboard stats (tasks, spending, agents)").action(async () => {
+  requireAuth2();
+  const { dashboardStats: dashboardStats2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
+  await dashboardStats2();
+});
+program.command("dashboard:complete <task-id>").description("Approve a delivery and release escrow to the agent").action(async (taskId) => {
+  requireAuth2();
+  const { completeTask: completeTask2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
+  await completeTask2(taskId);
+});
+program.command("dashboard:dispute <task-id>").description("Dispute a delivery \u2014 triggers review process").action(async (taskId) => {
+  requireAuth2();
+  const { disputeTask: disputeTask2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
+  await disputeTask2(taskId);
+});
+program.command("dashboard:evidence <task-id>").description("Submit evidence for a disputed task (buyer side)").action(async (taskId) => {
+  requireAuth2();
+  const { submitBuyerEvidence: submitBuyerEvidence2 } = await Promise.resolve().then(() => (init_dashboard(), dashboard_exports));
+  await submitBuyerEvidence2(taskId);
+});
+program.command("conversations").description("List all your message conversations").action(async () => {
+  requireAuth2();
+  const { listConversations: listConversations2 } = await Promise.resolve().then(() => (init_messages(), messages_exports));
+  await listConversations2();
+});
+program.command("conversations:view <task-id>").description("View messages in a conversation").action(async (taskId) => {
+  requireAuth2();
+  const { viewConversation: viewConversation2 } = await Promise.resolve().then(() => (init_messages(), messages_exports));
+  await viewConversation2(taskId);
+});
+program.command("conversations:send <task-id>").description("Send a message in a conversation").action(async (taskId) => {
+  requireAuth2();
+  const { sendConversationMessage: sendConversationMessage2 } = await Promise.resolve().then(() => (init_messages(), messages_exports));
+  await sendConversationMessage2(taskId);
+});
+program.command("conversations:search [query]").description("Search across all your messages").action(async (query) => {
+  requireAuth2();
+  const { searchMessages: searchMessages2 } = await Promise.resolve().then(() => (init_messages(), messages_exports));
+  await searchMessages2(query);
+});
+program.command("agents").description("List your registered agent listings").action(async () => {
+  requireAuth2();
+  const { listMyAgents: listMyAgents2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await listMyAgents2();
+});
+program.command("agents:register").description("Register a new agent on the marketplace").action(async () => {
+  requireAuth2();
+  const { registerAgent: registerAgent2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await registerAgent2();
+});
+program.command("agents:update <agent-id>").description("Update an agent listing (name, price, description)").action(async (agentId) => {
+  requireAuth2();
+  const { updateAgent: updateAgent2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await updateAgent2(agentId);
+});
+program.command("agents:delete <agent-id>").description("Permanently delete an agent listing").action(async (agentId) => {
+  requireAuth2();
+  const { deleteAgent: deleteAgent2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await deleteAgent2(agentId);
+});
+program.command("agents:stats [agent-id]").description("View agent performance stats and earnings").action(async (agentId) => {
+  requireAuth2();
+  const { agentStats: agentStats2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await agentStats2(agentId);
+});
+program.command("agents:inbox <agent-id>").description("View incoming tasks assigned to an agent").action(async (agentId) => {
+  requireAuth2();
+  const { inbox: inbox2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await inbox2(agentId);
+});
+program.command("agents:accept <agent-id> <task-id>").description("Accept an incoming task and submit a proposal").action(async (agentId, taskId) => {
+  requireAuth2();
+  const { acceptTask: acceptTask2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await acceptTask2(agentId, taskId);
+});
+program.command("agents:progress <task-id>").description("Report task progress (0-100%) with optional message").action(async (taskId) => {
+  requireAuth2();
+  const { updateProgress: updateProgress2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await updateProgress2(taskId);
+});
+program.command("agents:deliver <agent-id> <task-id>").description("Deliver a task with summary and proof").action(async (agentId, taskId) => {
+  requireAuth2();
+  const { deliverTask: deliverTask2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await deliverTask2(agentId, taskId);
+});
+program.command("agents:dispute <agent-id> <task-id>").description("Respond to a buyer dispute (accept & redeliver, or reject)").action(async (agentId, taskId) => {
+  requireAuth2();
+  const { respondToDispute: respondToDispute2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await respondToDispute2(agentId, taskId);
+});
+program.command("agents:evidence <agent-id> <task-id>").description("Submit arbitration evidence for a disputed task").action(async (agentId, taskId) => {
+  requireAuth2();
+  const { submitEvidence: submitEvidence2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await submitEvidence2(agentId, taskId);
+});
+program.command("agent:reviews <slug>").description("View reviews for an agent").action(async (slug) => {
+  const { viewAgentReviews: viewAgentReviews2 } = await Promise.resolve().then(() => (init_marketplace(), marketplace_exports));
+  await viewAgentReviews2(slug);
+});
+program.command("task:proposals <task-id>").description("View proposals received for a task").action(async (taskId) => {
+  requireAuth2();
+  const { listTaskProposals: listTaskProposals2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await listTaskProposals2(taskId);
+});
+program.command("task:accept-proposal <task-id>").description("Accept a proposal for a task").action(async (taskId) => {
+  requireAuth2();
+  const { acceptTaskProposal: acceptTaskProposal2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await acceptTaskProposal2(taskId);
+});
+program.command("hire-requests:respond <request-id>").description("Respond to a hire request (accept, reject, or negotiate)").action(async (requestId) => {
+  requireAuth2();
+  const { respondToHireRequest: respondToHireRequest2 } = await Promise.resolve().then(() => (init_hire(), hire_exports));
+  await respondToHireRequest2(requestId);
+});
+program.command("agents:hire-requests <agent-id>").description("List hire requests for an agent").action(async (agentId) => {
+  requireAuth2();
+  const { listAgentHireRequests: listAgentHireRequests2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await listAgentHireRequests2(agentId);
+});
+program.command("agents:hire-request <agent-id>").description("Create a hire request from an agent").action(async (agentId) => {
+  requireAuth2();
+  const { createAgentHireRequest: createAgentHireRequest2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await createAgentHireRequest2(agentId);
+});
+program.command("agents:hire-request:view <agent-id> <request-id>").description("View an agent hire request").action(async (agentId, requestId) => {
+  requireAuth2();
+  const { viewAgentHireRequest: viewAgentHireRequest2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await viewAgentHireRequest2(agentId, requestId);
+});
+program.command("agents:hire-request:respond <agent-id> <request-id>").description("Respond to an agent hire request").action(async (agentId, requestId) => {
+  requireAuth2();
+  const { respondAgentHireRequest: respondAgentHireRequest2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await respondAgentHireRequest2(agentId, requestId);
+});
+program.command("conversations:read <task-id>").description("Mark all messages in a conversation as read").action(async (taskId) => {
+  requireAuth2();
+  const { markConversationRead: markConversationRead2 } = await Promise.resolve().then(() => (init_messages(), messages_exports));
+  await markConversationRead2(taskId);
+});
+program.command("listings").description("List your service listings (alias for agents)").action(async () => {
+  requireAuth2();
+  const { listMyAgents: listMyAgents2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await listMyAgents2();
+});
+program.command("listings:create").description("Create a new service listing (alias for agents:register)").action(async () => {
+  requireAuth2();
+  const { registerAgent: registerAgent2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await registerAgent2();
+});
+program.command("listings:stats").description("View listing performance stats").argument("[id]", "Listing ID").action(async (id) => {
+  requireAuth2();
+  const { agentStats: agentStats2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await agentStats2(id);
+});
+program.command("listings:inbox").description("View incoming tasks for a listing").argument("<id>", "Listing ID").action(async (id) => {
+  requireAuth2();
+  const { inbox: inbox2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await inbox2(id);
+});
+program.command("listings:verify").description("Verify a listing by sending a heartbeat check").argument("<id>", "Listing ID").action(async (id) => {
+  requireAuth2();
+  const { verifyListing: verifyListing2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await verifyListing2(id);
+});
+program.command("listings:images").description("Manage listing images (upload, remove, set primary)").argument("<id>", "Listing ID").action(async (id) => {
+  requireAuth2();
+  const { manageImages: manageImages2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+  await manageImages2(id);
+});
+program.command("keys").description("List your API keys").action(async () => {
+  requireAuth2();
+  const { listKeys: listKeys2 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
+  await listKeys2();
+});
+program.command("keys:create").description("Create a new API key with scoped permissions").action(async () => {
+  requireAuth2();
+  const { createKey: createKey2 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
+  await createKey2();
+});
+program.command("keys:revoke [key-id]").description("Revoke an API key (permanent, cannot be undone)").action(async (keyId) => {
+  requireAuth2();
+  const { revokeKey: revokeKey2 } = await Promise.resolve().then(() => (init_keys(), keys_exports));
+  await revokeKey2(keyId);
+});
+program.command("config").description("Show CLI configuration (API URL, auth status, theme)").action(async () => {
+  const { showConfig: showConfig2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await showConfig2();
+});
+program.command("config:set <key> <value>").description("Set a config value (apiUrl, theme)").action(async (key, value) => {
+  const { setConfigValue: setConfigValue3 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  await setConfigValue3(key, value);
+});
+program.command("health").description("Check g0 platform health and API connectivity").action(async () => {
+  const { getApiUrl: getApiUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { spin: spin2, c: colors } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+  const s = spin2("Checking platform health...");
+  try {
+    const res = await fetch(`${getApiUrl2()}/api/v1/health`, {
+      headers: { "User-Agent": "@g0hub/cli/1.0.0" }
+    });
+    const data = await res.json();
+    if (data.status === "healthy") {
+      s.succeed(
+        colors.success("Platform is healthy") + (data.version ? colors.dim(` (v${data.version})`) : "")
+      );
+    } else {
+      s.warn(
+        colors.warn("Platform is degraded") + (data.version ? colors.dim(` (v${data.version})`) : "")
+      );
+    }
+    if (data.checks) {
+      for (const [name, check] of Object.entries(data.checks)) {
+        const icon = check.status === "ok" ? colors.success("\u2713") : colors.err("\u2717");
+        console.log(`    ${icon} ${name} ${colors.dim(`(${check.latencyMs}ms)`)}`);
+      }
+    }
+    if (data.agents) {
+      console.log(`    ${colors.cool("\u25CF")} ${data.agents.online} agent${data.agents.online !== 1 ? "s" : ""} online`);
+    }
+  } catch {
+    s.fail("Platform unreachable \u2014 cannot connect to " + getApiUrl2());
+  }
+});
+program.action(() => {
+  banner();
+  program.outputHelp();
+  console.log();
+});
+function requireAuth2() {
+  if (!isAuthenticated()) {
+    console.error(
+      c.err.bold("\n  \u2717 Not authenticated.") + c.muted('\n    Run "g0 login" or "g0 auth:key <key>" first.\n')
+    );
+    process.exit(1);
+  }
+}
+program.parseAsync().catch((err) => {
+  showError(err);
+  process.exit(1);
+});