@t2000/cli 10.27.2 → 10.29.0

package/dist/index.js

@@ -28274,28 +28274,6 @@ var SUPPORTED_ASSETS = {
   }
 };
 var STABLE_ASSETS = ["USDC", "USDsui"];
-var OPERATION_ASSETS = {
-  send: ["USDC", "USDsui", "SUI"],
-  swap: "*"
-};
-function isAllowedAsset(op, asset) {
-  const allowed = OPERATION_ASSETS[op];
-  if (allowed === "*") return true;
-  const target = asset.toLowerCase();
-  return allowed.some((a) => a.toLowerCase() === target);
-}
-function assertAllowedAsset(op, asset) {
-  if (!asset) return;
-  if (!isAllowedAsset(op, asset)) {
-    const allowed = OPERATION_ASSETS[op];
-    const list = Array.isArray(allowed) ? allowed.join(", ") : "any";
-    const swapHint = op === "send" ? " Swap to USDC or USDsui first, or send SUI." : "";
-    throw new T2000Error(
-      "INVALID_ASSET",
-      `${op} only supports ${list}. Cannot use ${asset}.${swapHint}`
-    );
-  }
-}
 var GASLESS_STABLE_TYPES = {
   USDC: SUPPORTED_ASSETS.USDC.type,
   USDsui: SUPPORTED_ASSETS.USDsui.type
@@ -28899,19 +28877,42 @@ for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
     ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
   }
 }
+init_token_registry();
 init_preflight();
-function preflightSend(input) {
+function classifySendAsset(asset) {
+  const coinType = resolveTokenType(asset.trim());
+  if (!coinType) return null;
+  let normalized;
   try {
-    assertAllowedAsset("send", input.asset);
-  } catch (e) {
-    return preflightFail("INVALID_ASSET", e.message);
+    normalized = normalizeStructTag(coinType);
+  } catch {
+    return null;
+  }
+  if (normalized === normalizeStructTag(GASLESS_STABLE_TYPES.USDC)) {
+    return { kind: "gasless-stable", symbol: "USDC", coinType: GASLESS_STABLE_TYPES.USDC };
+  }
+  if (normalized === normalizeStructTag(GASLESS_STABLE_TYPES.USDsui)) {
+    return { kind: "gasless-stable", symbol: "USDsui", coinType: GASLESS_STABLE_TYPES.USDsui };
+  }
+  if (normalized === normalizeStructTag(SUI_TYPE)) {
+    return { kind: "sui", symbol: "SUI", coinType: SUI_TYPE };
+  }
+  return { kind: "coin", symbol: resolveSymbol(coinType), coinType };
+}
+function invalidSendAssetMessage(asset) {
+  return `Unknown asset "${asset}". Use a registry symbol (USDC, USDsui, SUI, MANIFEST, \u2026) or a full coin type (0x\u2026::module::TYPE).`;
+}
+function preflightSend(input) {
+  const cls = classifySendAsset(input.asset);
+  if (!cls) {
+    return preflightFail("INVALID_ASSET", invalidSendAssetMessage(input.asset));
   }
   const amountCheck = checkPositiveAmount(input.amount);
   if (!amountCheck.valid) return amountCheck;
-  if ((input.asset === "USDC" || input.asset === "USDsui") && input.amount < GASLESS_MIN_STABLE_AMOUNT) {
+  if (cls.kind === "gasless-stable" && input.amount < GASLESS_MIN_STABLE_AMOUNT) {
     return preflightFail(
       "INVALID_AMOUNT",
-      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${input.asset}. Got ${input.amount}.`
+      `Minimum gasless transfer is ${GASLESS_MIN_STABLE_AMOUNT} ${cls.symbol}. Got ${input.amount}.`
     );
   }
   const addressCheck = checkSuiAddress(input.to);
@@ -28928,42 +28929,44 @@ async function buildSendTx({
   const pf = preflightSend({ to, amount, asset });
   if (!pf.valid) throw new T2000Error(pf.code, pf.error);
   const recipient = validateAddress(to);
-  const assetInfo = SUPPORTED_ASSETS[asset];
-  if (!assetInfo) throw new T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
-  const rawAmount = displayToRaw(amount, assetInfo.decimals);
+  const cls = classifySendAsset(asset);
+  const decimals = cls.kind === "gasless-stable" || cls.kind === "sui" ? SUPPORTED_ASSETS[cls.symbol].decimals : await resolveCoinDecimals(client, cls.coinType);
+  const rawAmount = displayToRaw(amount, decimals);
   const tx = new Transaction();
   tx.setSender(address);
-  const balanceResp = await client.core.getBalance({ owner: address, coinType: assetInfo.type });
+  const balanceResp = await client.core.getBalance({ owner: address, coinType: cls.coinType });
   const totalBalance = BigInt(balanceResp.balance.balance);
   if (totalBalance < rawAmount) {
-    throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${asset} balance`, {
-      available: Number(totalBalance) / 10 ** assetInfo.decimals,
+    throw new T2000Error("INSUFFICIENT_BALANCE", `Insufficient ${cls.symbol} balance`, {
+      available: Number(totalBalance) / 10 ** decimals,
       required: amount
     });
   }
-  if (asset === "USDC" || asset === "USDsui") {
-    const rawFloor = displayToRaw(GASLESS_MIN_STABLE_AMOUNT, assetInfo.decimals);
-    const remainder = totalBalance - rawAmount;
-    if (remainder > 0n && remainder < rawFloor) {
-      const total = Number(totalBalance) / 10 ** assetInfo.decimals;
-      throw new T2000Error(
-        "INVALID_AMOUNT",
-        `Gasless ${asset} transfers must send the entire balance or leave at least ${GASLESS_MIN_STABLE_AMOUNT} ${asset}. Sending ${amount} of ${total} leaves ${(total - amount).toFixed(assetInfo.decimals)}. Send ${total} (everything) or at most ${(total - GASLESS_MIN_STABLE_AMOUNT).toFixed(assetInfo.decimals)}.`,
-        { available: total, required: amount }
-      );
-    }
-  }
-  if (asset === "SUI") {
+  if (cls.kind === "sui") {
     const [sendCoin] = tx.splitCoins(tx.gas, [rawAmount]);
     tx.transferObjects([sendCoin], recipient);
     return tx;
   }
-  const coinType = GASLESS_STABLE_TYPES[asset];
+  if (cls.kind === "coin") {
+    const sendCoin = coinWithBalance({ type: cls.coinType, balance: rawAmount })(tx);
+    tx.transferObjects([sendCoin], recipient);
+    return tx;
+  }
+  const rawFloor = displayToRaw(GASLESS_MIN_STABLE_AMOUNT, decimals);
+  const remainder = totalBalance - rawAmount;
+  if (remainder > 0n && remainder < rawFloor) {
+    const total = Number(totalBalance) / 10 ** decimals;
+    throw new T2000Error(
+      "INVALID_AMOUNT",
+      `Gasless ${cls.symbol} transfers must send the entire balance or leave at least ${GASLESS_MIN_STABLE_AMOUNT} ${cls.symbol}. Sending ${amount} of ${total} leaves ${(total - amount).toFixed(decimals)}. Send ${total} (everything) or at most ${(total - GASLESS_MIN_STABLE_AMOUNT).toFixed(decimals)}.`,
+      { available: total, required: amount }
+    );
+  }
   tx.moveCall({
     target: "0x2::balance::send_funds",
-    typeArguments: [coinType],
+    typeArguments: [cls.coinType],
     arguments: [
-      tx.balance({ type: coinType, balance: rawAmount }),
+      tx.balance({ type: cls.coinType, balance: rawAmount }),
       tx.pure.address(recipient)
     ]
   });
@@ -30349,18 +30352,17 @@ var T2000 = class _T2000 extends import_index2.default {
   /**
    * Send `amount` of `asset` to `to` (hex address or SuiNS name).
    *
-   * [v4.0 Phase A Day 2 — SPEC_AGENT_WALLET_GREENFIELD §A]
+   * [S.957 — 2026-08-08] `asset` accepts **any held coin type** — a
+   * registry symbol (`USDC`, `MANIFEST`) or a full `0x…::module::TYPE`.
+   * Unresolvable strings throw `INVALID_ASSET`; empty balances throw
+   * `INSUFFICIENT_BALANCE`.
    *
-   * **Breaking changes from v3.x:**
-   * - `asset` is now REQUIRED (no implicit `?? 'USDC'` default). Callers
-   *   must specify `'USDC' | 'USDsui' | 'SUI'`. Sending `'USDT'` /
-   *   `'USDe'` / `'WAL'` / `'ETH'` / `'NAVX'` / `'GOLD'` now errors
-   *   with `INVALID_ASSET` — swap to a stable first.
    * - USDC + USDsui builds go through `SuiGrpcClient` so the gRPC build
    *   resolver auto-detects `0x2::balance::send_funds` eligibility and
-   *   zeros gas at simulate time. Result: **gasless USDC / USDsui sends
-   *   from a zero-SUI wallet.** SUI sends stay on the standard gas-paid
-   *   path.
+   *   zeros gas at simulate time — **gasless sends from a zero-SUI
+   *   wallet.** They remain the ONLY gasless assets.
+   * - SUI and every other coin type are gas-paid (the sender needs SUI).
+   * - `asset` stays REQUIRED (no implicit `?? 'USDC'` default — v4 rule).
    *
    * Submission stays on the JSON-RPC client (the rest of the SDK
    * expects JSON-RPC for read paths, and Sui's docs explicitly support
@@ -30371,30 +30373,31 @@ var T2000 = class _T2000 extends import_index2.default {
     if (!asset) {
       throw new T2000Error(
         "INVALID_ASSET",
-        "send() requires an explicit asset. Use one of: USDC, USDsui, SUI."
+        "send() requires an explicit asset. Use a registry symbol (USDC, USDsui, SUI, MANIFEST, \u2026) or a full coin type (0x\u2026::module::TYPE)."
       );
     }
-    assertAllowedAsset("send", asset);
-    const sendableAsset = asset;
+    const cls = classifySendAsset(asset);
+    if (!cls) {
+      throw new T2000Error("INVALID_ASSET", invalidSendAssetMessage(asset));
+    }
     this.limits.assert({
       operation: "send",
-      amountUsd: approxUsdValue(sendableAsset, params.amount) ?? 0,
+      amountUsd: approxUsdValue(cls.symbol, params.amount) ?? 0,
       force: params.force
     });
     const resolved = await this.resolveRecipient(params.to);
     const sendAmount = params.amount;
     const sendTo = resolved.address;
-    const useGrpc = sendableAsset === "USDC" || sendableAsset === "USDsui";
-    const buildClient = useGrpc ? getSuiGrpcClient() : void 0;
+    const buildClient = cls.kind === "gasless-stable" ? getSuiGrpcClient() : void 0;
     const gasResult = await executeTx(
       this.client,
       this._signer,
-      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset: sendableAsset }),
+      () => buildSendTx({ client: this.client, address: this._address, to: sendTo, amount: sendAmount, asset }),
       { buildClient }
     );
-    this.limits.record(approxUsdValue(sendableAsset, sendAmount) ?? 0);
+    this.limits.record(approxUsdValue(cls.symbol, sendAmount) ?? 0);
     const balance = await this.balance();
-    this.emitBalanceChange(sendableAsset, sendAmount, "send", gasResult.digest);
+    this.emitBalanceChange(cls.symbol, sendAmount, "send", gasResult.digest);
     return {
       success: true,
       tx: gasResult.digest,
@@ -30820,6 +30823,34 @@ async function getJobSpec(base, hash) {
   }
   return content;
 }
+var TITLE_PREFIX_RE = /^title\s*:\s*(.+)$/i;
+var ENVELOPE_TITLE_MAX = 80;
+function customHireEnvelope(brief, title, now) {
+  const body2 = brief.trim();
+  let t = title?.trim() ?? "";
+  if (!t) {
+    const first = body2.split("\n").find((l) => l.trim())?.trim() ?? "";
+    const prefixed = TITLE_PREFIX_RE.exec(first);
+    t = (prefixed ? prefixed[1] : first).trim();
+  }
+  if (t.length > ENVELOPE_TITLE_MAX) {
+    t = `${t.slice(0, ENVELOPE_TITLE_MAX - 1).trimEnd()}\u2026`;
+  }
+  return JSON.stringify({
+    type: "t2-acp-custom@1",
+    title: t || "Custom job",
+    brief: body2,
+    createdAtMs: now
+  });
+}
+function isCustomHireEnvelope(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return (parsed.type === "t2-acp-custom@1" || parsed.type === "t2-acp-invite@1") && typeof parsed.brief === "string" && parsed.brief.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
 async function fetchJson(url, init) {
   const res = await fetch(url, {
     method: init?.method ?? "GET",
@@ -34104,20 +34135,19 @@ function registerStatus(program3) {
 
 // src/commands/send.ts
 var import_picocolors6 = __toESM(require_picocolors(), 1);
-var ACCEPTED_ASSETS = ["USDC", "USDsui", "SUI"];
-var ACCEPTED_ASSETS_LIST = ACCEPTED_ASSETS.join(", ");
+var ASSET_HINT = "a registry symbol (USDC, USDsui, SUI, MANIFEST, \u2026) or a full coin type (0x\u2026::module::TYPE)";
 function parseSendArgs(args) {
   const filtered = args.filter((a) => a.toLowerCase() !== "to");
   if (filtered.length < 2) {
     throw new Error(
       `Usage: t2 send <amount> <asset> <recipient>
-  asset must be one of: ${ACCEPTED_ASSETS_LIST}
+  asset is ${ASSET_HINT}
   recipient can be a 0x address or SuiNS name (alice.sui, alice.audric.sui)`
     );
   }
   if (filtered.length === 2) {
     throw new Error(
-      `Missing required <asset> argument. Use one of: ${ACCEPTED_ASSETS_LIST}. Example: t2 send ${filtered[0]} USDC ${filtered[1]}`
+      `Missing required <asset> argument. Use ${ASSET_HINT}. Example: t2 send ${filtered[0]} USDC ${filtered[1]}`
     );
   }
   const amount = parseFloat(filtered[0]);
@@ -34125,36 +34155,34 @@ function parseSendArgs(args) {
     throw new Error(`Amount must be a positive number (got "${filtered[0]}").`);
   }
   const candidate = filtered[1];
-  const normalized = normalizeAssetSymbol(candidate);
-  if (!normalized) {
+  const cls = classifySendAsset(candidate);
+  if (!cls) {
     throw new Error(
-      `Unsupported asset "${candidate}". Use one of: ${ACCEPTED_ASSETS_LIST}. Swap to USDC or USDsui first with \`t2 swap\`, or send SUI.`
+      `Unknown asset "${candidate}". Use ${ASSET_HINT}. Check your holdings with \`t2 balance\`.`
     );
   }
   const recipient = filtered[2];
   if (!recipient) {
     throw new Error(`Missing recipient. Usage: t2 send <amount> <asset> <recipient>.`);
   }
-  return { amount, asset: normalized, recipient };
-}
-function normalizeAssetSymbol(input) {
-  const lower = input.toLowerCase();
-  if (lower === "usdc") return "USDC";
-  if (lower === "usdsui") return "USDsui";
-  if (lower === "sui") return "SUI";
-  return void 0;
+  const asset = cls.kind === "gasless-stable" || cls.kind === "sui" ? cls.symbol : candidate;
+  return { amount, asset, recipient };
 }
 function registerSend(program3) {
   program3.command("send").argument("<amount>", "Amount of <asset> to send (denominated in asset units, NOT USD)").argument(
     "[args...]",
-    'Asset (USDC | USDsui | SUI), optional "to" keyword, and recipient (0x address or SuiNS name like alice.sui)'
-  ).description("Send USDC, USDsui, or SUI. USDC + USDsui are gasless (no SUI required).").option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").option("--force", "Override spending limits for this call (see `t2 limit`)").addHelpText(
+    'Asset (registry symbol like USDC / MANIFEST, or a full 0x\u2026::module::TYPE coin type), optional "to" keyword, and recipient (0x address or SuiNS name like alice.sui)'
+  ).description(
+    "Send any held token. USDC + USDsui are gasless; everything else needs SUI for gas."
+  ).option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").option("--force", "Override spending limits for this call (see `t2 limit`)").addHelpText(
     "after",
     `
 Examples:
   $ t2 send 5 USDC 0xabc\u2026              Send 5 USDC (gasless) to a hex address
   $ t2 send 5 USDsui alice.sui         Send 5 USDsui (gasless) to a SuiNS name
   $ t2 send 0.1 SUI alice.audric.sui   Send 0.1 SUI (gas required) to a SuiNS subname
+  $ t2 send 10 MANIFEST 0xabc\u2026         Send any held token (gas required)
+  $ t2 send 10 0xc466\u2026::manifest::MANIFEST 0xabc\u2026   Full coin type works too
 `
   ).action(async (amount, args, opts) => {
     try {
@@ -34163,9 +34191,8 @@ Examples:
       const result = await agent.send({
         to: recipient,
         amount: parsedAmount,
-        // The CLI parser already narrowed asset to USDC / USDsui / SUI;
-        // the SDK accepts `SupportedAsset` and re-validates via
-        // `assertAllowedAsset('send', …)` at runtime.
+        // [S.957] Any resolvable asset string — the SDK re-resolves via
+        // `classifySendAsset` (same rule the parser used).
         asset,
         force: opts.force
       });
@@ -34178,7 +34205,7 @@ Examples:
         return;
       }
       const displayTo = result.suinsName ? `${result.suinsName} ${import_picocolors6.default.dim(`(${truncateAddress(result.to)})`)}` : truncateAddress(result.to);
-      const amountDisplay = asset === "SUI" ? `${result.amount.toFixed(4)} SUI` : `${formatUsd(result.amount)} ${asset}`;
+      const amountDisplay = asset === "USDC" || asset === "USDsui" ? `${formatUsd(result.amount)} ${asset}` : asset === "SUI" ? `${result.amount.toFixed(4)} SUI` : `${result.amount} ${asset}`;
       printBlank();
       printSuccess(`Sent ${amountDisplay} \u2192 ${displayTo}`);
       if (result.gasCost === 0) {
@@ -36224,10 +36251,10 @@ function parseDuration(input) {
 }
 var SHA256_HEX_RE = /^0x[0-9a-fA-F]{64}$/;
 var SPEC_STORE_MAX_BYTES = 16 * 1024;
-async function resolveSpecUpload(base, input) {
+async function loadSpecText(input) {
   const trimmed = input.trim();
   if (SHA256_HEX_RE.test(trimmed)) {
-    return { hash: trimmed.toLowerCase(), uploaded: false };
+    return { kind: "hash", hash: trimmed.toLowerCase() };
   }
   let bytes;
   try {
@@ -36248,7 +36275,27 @@ async function resolveSpecUpload(base, input) {
       "Content is not UTF-8 text \u2014 the job-spec store holds text only. Upload a short note that LINKS the artifact, or pin a precomputed commitment with --hash-only 0x<sha256>."
     );
   }
-  return { hash: `0x${await putJobSpec(base, text)}`, uploaded: true };
+  return { kind: "text", text };
+}
+async function resolveSpecUpload(base, input) {
+  const loaded = await loadSpecText(input);
+  if (loaded.kind === "hash") {
+    return { hash: loaded.hash, uploaded: false };
+  }
+  return { hash: `0x${await putJobSpec(base, loaded.text)}`, uploaded: true };
+}
+async function resolveHireSpecUpload(base, input, title) {
+  const loaded = await loadSpecText(input);
+  if (loaded.kind === "hash") {
+    return { hash: loaded.hash, uploaded: false };
+  }
+  const body2 = isCustomHireEnvelope(loaded.text) ? loaded.text : customHireEnvelope(loaded.text, title, Date.now());
+  if (Buffer.byteLength(body2, "utf8") > SPEC_STORE_MAX_BYTES) {
+    throw new Error(
+      "The brief plus its envelope exceeds the 16 KiB job-spec store cap \u2014 shorten the brief, or link the long artifact (URL / IPFS)."
+    );
+  }
+  return { hash: `0x${await putJobSpec(base, body2)}`, uploaded: true };
 }
 function stateColor(state) {
   if (state === "released") return import_picocolors13.default.green(state);
@@ -36349,7 +36396,7 @@ no fund step; unclaimed openings refund fee-free):
   ASP     $ t2 job board \xB7 t2 job claim <openingId>
 `
   );
-  group.command("hire").alias("create").argument("[amount]", `USDC to escrow (max ${MAX_JOB_USDC}; omit when hiring a --service listing)`).argument("[seller]", "The ASP's Sui address (omit when hiring a --service listing)").description("Hire \u2014 fund an escrow job in one transaction (buyer): a listing (--agent + --service) or your own terms (amount + seller + --spec)").option("--spec <file-or-text>", "Job spec \u2014 a file path or inline text (UPLOADED so the seller can read it; sha256 pinned on-chain), or a bare 0x\u2026 sha256 (confidential: pins without uploading)").option(
+  group.command("hire").alias("create").argument("[amount]", `USDC to escrow (max ${MAX_JOB_USDC}; omit when hiring a --service listing)`).argument("[seller]", "The ASP's Sui address (omit when hiring a --service listing)").description("Hire \u2014 fund an escrow job in one transaction (buyer): a listing (--agent + --service) or your own terms (amount + seller + --spec)").option("--spec <file-or-text>", "Job spec \u2014 a file path or inline text (UPLOADED as the public t2-acp-custom@1 title+brief envelope so the seller and the store can read it; sha256 pinned on-chain), or a bare 0x\u2026 sha256 (confidential: pins without uploading, no envelope)").option("--title <text>", "Public job title (\u226480 chars). Custom/direct hire only; derived from the brief's first line if omitted").option(
     "--agent <address|#id|@handle>",
     "Hire a listing: the ASP's agent address, #id, or @handle"
   ).option("--service <slug>", "The service slug (see t2 services / t2 service list <agent>)").option("--requirements <file-or-json-or-text>", "What the seller asked buyers to provide \u2014 if the listing lists JSON keys, fill EVERY key (JSON object; extra keys OK)").option("--deadline <duration>", "Time the seller has to deliver (e.g. 30m, 24h, 7d)", "24h").option("--review <duration>", "Your accept/reject window after delivery", "24h").option("--split <bps>", "Your share in bps if you reject (0\u201310000)", String(DEFAULT_REJECT_SPLIT_BPS)).option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").option("--api <url>", `API base URL (default ${DEFAULT_API_BASE7})`).action(
@@ -36429,7 +36476,11 @@ no fund step; unclaimed openings refund fee-free):
           seller = validateAddress(
             (await resolveAgentRef(base, sellerArg)).address
           );
-          ({ hash: specHash } = await resolveSpecUpload(base, opts.spec));
+          ({ hash: specHash } = await resolveHireSpecUpload(
+            base,
+            opts.spec,
+            opts.title
+          ));
           deliverByMs = Date.now() + parseDuration(opts.deadline);
           reviewWindowMs = opts.review ? parseDuration(opts.review) : DEFAULT_REVIEW_WINDOW_MS;
           rejectSplitBps = Number.parseInt(opts.split, 10);
@@ -36895,9 +36946,9 @@ Examples:
   $ t2 service retire sui-market-report
 `
   );
-  group.command("create").description("List a service under your Agent ID (re-run to update it)").requiredOption("--name <name>", "Service name (max 80 chars)").requiredOption("--price <usdc>", "Fixed price in USDC (0.01\u201350)").requiredOption("--sla <duration>", "Delivery SLA \u2014 e.g. 30m, 24h, 7d").requiredOption("--description <text>", "What this service is (max 2000 chars)").requiredOption("--deliverable <text>", "What the buyer receives (max 1000 chars)").option("--slug <slug>", "Machine name (default: derived from --name)").option(
+  group.command("create").description("List a service under your Agent ID (re-run to update it)").requiredOption("--name <name>", "Service name (max 80 chars)").requiredOption("--price <usdc>", "Fixed price in USDC (0.01\u201350)").requiredOption("--sla <duration>", "Delivery SLA \u2014 e.g. 30m, 24h, 7d").requiredOption("--description <text>", "What this service is (max 2000 chars)").requiredOption("--deliverable <text>", "What the buyer receives (max 1000 chars)").option("--slug <slug>", "Machine name (default: derived from --name)").requiredOption(
     "--requirements <file-or-json-or-text>",
-    "What the buyer must provide \u2014 prefer a JSON object of required fields (keys enforced non-empty at hire); free text ok (file path ok)"
+    "The questions buyers answer at hire (REQUIRED \u2014 the API rejects listings that ask nothing): free text, or a JSON object of field names \u2192 hints (keys enforced non-empty at hire; file path ok)"
   ).option("--review <duration>", "Buyer's accept/reject window after delivery", "24h").option("--split <bps>", "Buyer's share in bps if they reject (0\u201310000)", "8000").option(
     "--category <category>",
     `Directory category for your listing: ${AGENT_CATEGORIES.join(" | ")} (required unless already set on your profile)`