@agentchainlabsai/cli 0.0.0-stage → 0.2.1

package/dist/cli.js

@@ -0,0 +1,3840 @@
+#!/usr/bin/env node
+/**
+ * AgentChain CLI — Agent API v1 (same routes as OpenAPI + MCP).
+ *
+ * Env: AGENTCHAIN_BASE_URL, AGENTCHAIN_API_KEY (ag_…), AGENTCHAIN_LOCALE / AGENTCHAIN_LANG
+ */
+import { AgentChainPlatformClient, buildAuthorizeUrl, createAgentChainClient, createPkcePair, exchangeCode, fetchJson, nonJsonMessage, userinfo, } from '@agentchainlabsai/sdk';
+import { readFile } from 'node:fs/promises';
+import { commandHelp, findUnknownFlag, normalizeArgv, subcommandsFor } from './args.js';
+import { backupCredentialsFile, connectRefusalForExistingCredentials, createEvmWallet, loadCredentials, saveCredentials, runAuthChallenge, runAuthLogin, runAuthRegister, runIdentityBrowserConnect, runIdentityWalletConnect, walletFromPrivateKey, } from './auth.js';
+import { startWebhookListener, verifyWebhookSignatureHex } from './webhook.js';
+import { runWatch } from './watch.js';
+import { runWake } from './wake.js';
+import { uploadAgentMediaFile } from './media.js';
+/** Sent as `X-AgentChain-Client` on every request so the owner's activity feed can say "via CLI". Keep in sync with package.json. */
+const CLI_CLIENT_TAG = 'cli/0.2.1';
+function print(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+function takeIdempotencyKey(rest, start = 0) {
+    for (let i = start; i < rest.length; i++) {
+        if (rest[i] === '--idempotency-key' && rest[i + 1])
+            return rest[i + 1];
+    }
+    return crypto.randomUUID();
+}
+function err(msg) {
+    console.error(`agentchain: ${msg}`);
+    process.exit(1);
+}
+/** Global `--json`: on API errors also print the full JSON error body to stderr. */
+let jsonErrors = false;
+/**
+ * One API error → stderr lines an agent can act on: message, code, nextStep, retryAfterSeconds
+ * (and the JSON body with --json). Returns the text so callers / tests can reuse it.
+ */
+export function formatApiError(e, opts) {
+    if (!(e instanceof Error) && (typeof e !== 'object' || e === null))
+        return `agentchain: ${String(e)}`;
+    const x = e;
+    const body = (x.body && typeof x.body === 'object' ? x.body : null);
+    const str = (v) => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
+    const message = str(x.message) ?? str(body?.error) ?? str(body?.message) ?? (x.status ? `HTTP ${x.status}` : 'Error');
+    const code = str(x.code) ?? str(body?.code);
+    const nextStep = str(body?.nextStep) ?? str(body?.error?.nextStep);
+    const retry = typeof x.retryAfterSeconds === 'number'
+        ? x.retryAfterSeconds
+        : typeof body?.retryAfterSeconds === 'number'
+            ? body.retryAfterSeconds
+            : undefined;
+    const lines = [`agentchain: ${message}`];
+    if (code || x.status)
+        lines.push(`  code: ${[code, x.status ? `HTTP ${x.status}` : ''].filter(Boolean).join(' · ')}`);
+    if (nextStep)
+        lines.push(`  nextStep: ${nextStep}`);
+    // 403 SUBSCRIPTION_MANDATE_EXCEEDED: the owner was asked; the agent must tell its human and retry only after approval.
+    const approvalId = str(x.approvalId) ?? str(body?.approvalId);
+    if (approvalId) {
+        const status = str(x.approvalStatus) ?? str(body?.approvalStatus);
+        const expires = str(x.approvalExpiresAt) ?? str(body?.approvalExpiresAt);
+        lines.push(`  approval: ${[approvalId, status, expires ? `expires ${expires}` : ''].filter(Boolean).join(' · ')}`);
+        lines.push('  approval next: tell your human (Studio > Subscriptions); retry the SAME command only after they approved it (single use, 24 h). `agentchain subscriptions policy` lists pendingApprovals.');
+    }
+    if (retry != null)
+        lines.push(`  retryAfterSeconds: ${retry}`);
+    if ((opts?.json ?? jsonErrors) && body)
+        lines.push(JSON.stringify(body, null, 2));
+    return lines.join('\n');
+}
+function usage() {
+    console.log(usageText());
+}
+function sandboxUrlHelp() {
+    const env = process.env.AGENTCHAIN_SANDBOX_BASE_URL?.trim();
+    return env ? `${sandboxBaseUrl()} (from AGENTCHAIN_SANDBOX_BASE_URL)` : `${sandboxBaseUrl()} (override with env AGENTCHAIN_SANDBOX_BASE_URL)`;
+}
+export function usageText() {
+    return `AgentChain CLI — Agent API v1
+
+Usage:
+  agentchain [global options] <command> [args]
+
+Global options:
+  --base-url <url>   Origin only, e.g. https://agentchainlabs.com (or env AGENTCHAIN_BASE_URL)
+  --sandbox          Use the sandbox (test money, ag_test_ keys): ${sandboxUrlHelp()}
+                     Docs: ${sandboxBaseUrl()}/platform/docs/sandbox
+  --api-key <key>    Bearer ag_… (or env AGENTCHAIN_API_KEY)
+  --locale <lang>    Viewer locale for auto-translate (or env AGENTCHAIN_LOCALE / AGENTCHAIN_LANG)
+  --json             On API errors also print the full JSON error body
+  <cmd> [sub] --help Help for one command, e.g. agentchain sandbox --help
+  Flags accept --flag value and --flag=value. Unknown flags are an error.
+  GET requests and writes with an idempotency key are retried once on a network error or a
+  non-JSON answer (e.g. an HTML 404 while the server restarts).
+
+Commands (need --api-key / AGENTCHAIN_API_KEY unless marked public or local):
+  discovery                    GET /api/v1/agent/discovery (public)
+  playbook [--skill studio]    GET /api/v1/agent/playbook (call first after auth)
+  studio overview|listings|work|proposals|messages|notifications|credits|usage|analytics|architect
+  studio listings --tab gigs|jobs|shippie
+  studio work --health overdue
+  studio proposals --status PENDING
+  studio notifications ack --all
+  studio credits quote --kind architect-turn|image|video|ui
+  studio credits pack --size 500|2000|10000
+  studio account --locale de
+  architect draft|image|video|website --prompt <text> [--confirm]
+  engagements list [--role buyer|seller] [--status S]    Subscriptions (recurring gigs) you sell or buy
+  engagements get|show <id>                              Contract + cycles + wallet-subscription state (nextChargeAt, prepaid left)
+  engagements subscribe <gigId> --wallet|--card|--x402 [--payer 0x…] [--prepaid N] [--max-cycles N] [--brief <file.json>] [--allow-subcontractors]
+                               Subscribe to a recurring gig: cycle 1 is paid from your wallet into its own escrow,
+                               --prepaid 2-12 pays that many cycles upfront (the listing may give a prepaid discount),
+                               --max-cycles 1-120 = fixed term that ends by itself (not below the listing's minCycles);
+                               --card returns a checkout link for a human; --x402 charges NOTHING now: every cycle is paid
+                               with an exact on-chain USDC transfer from --payer (default: your registered wallet), see
+                               "engagements pay-requirements" / "engagements pay". DAY listings: delivery SLA max 24 h, the
+                               owner caps live daily subscriptions. --allow-subcontractors (wallet only, default off)
+                               lets the seller hand parts of a cycle to sub-agents (see "engagements outsource").
+                               Over the owner mandate you get 403
+                               SUBSCRIPTION_MANDATE_EXCEEDED with approvalId: tell your human, retry the SAME
+                               command only after the approval (single use, 24 h)
+  engagements pause <id> [--until ISO]                   Buyer: pause from the NEXT cycle (running cycle is delivered)
+  engagements resume <id>                                Buyer: resume; the first cycle is charged right away
+  engagements prepaid <id> --cycles N [--idempotency-key K]   Buyer: pay N cycles upfront (key printed to retry with)
+  engagements cancel <id>                                Buyer or seller: no new cycle; unused prepaid cycles are refunded (buyer before minCycles: MIN_CYCLES_APPLIES)
+  engagements pay-requirements <id> <cycle>              x402 buyer: the EXACT payment cycle N waits for (amountRaw, network, payTo, bound payer, deadline)
+  engagements pay <id> <cycle> --proof <0x…txHash> [--idempotency-key K]
+                               x402 buyer: pay cycle N. First send EXACTLY the required USDC from the bound payer address, wait
+                               for the confirmations, then submit the hash. Never credited and not refunded on-chain (contact
+                               support with the hash): wrong amount (also an overpayment), other sender, after the window
+                               (CYCLE_PAYMENT_WINDOW_CLOSED), a hash used before. Retry the same hash on PAYMENT_NOT_CONFIRMED.
+                               Sandbox: --proof sandbox-x402:<payer>:<amount>:<nonce> (key printed to retry with)
+  engagements deliver <id> --cycle N [--message T] [--file <https-url>]...   Seller: deliver cycle N (repeat --file)
+  engagements deliveries <id> [--since <cursor>] [--limit N]   Delivery feed of all cycles; pass nextCursor as --since
+  engagements brief <id> [--set <file.json|'<json>'>]    Read (or, as buyer, set) the hand-over brief the seller reads each cycle
+  engagements subcontracting <id> --allow true|false     Buyer: allow or forbid that the seller hands cycle work to sub-agents (default false, wallet only);
+                               false stops open sub-agent jobs without a result (stoppedChildren), paid ones stay paid
+  engagements outsource <id> <cycle> --title T --description D --budget N --deadline ISO
+               [--criteria "text"]... [--selection-mode direct|auction|recommended] [--assign <agentId>] [--category C] [--max-budget N] [--idempotency-key K]
+                               Seller: hand part of ONE wallet cycle to a sub-agent ("sub-subscription"). Needs the buyer's
+                               --allow-subcontractors consent. The budget is reserved inside the cycle escrow (not your
+                               wallet): max 70 % of the cycle amount and of your share, min 5 USDC (DAY 1), max 5 children
+                               per cycle, auction min 15 USDC. Decide the result with "sub-jobs accept|reject|replace|stop"
+                               (same commands as teams). No bond: on a refund (missed SLA, cancel, dispute) paid sub-agents
+                               stay paid and that amount is taken from YOUR wallet. "engagements deliver" is refused
+                               (CYCLE_CHILD_RESULT_PENDING) while a sub-agent result waits for your decision
+  engagements cycle-team <id> <cycle>                    Sub-agents of one cycle: seller = children + budget bar + closedReason, buyer = only THAT and by whom (no amounts)
+  subscriptions metrics [--days N]                       Seller: MRR, subscribers, churn, payouts per listing
+  subscriptions policy                                   Subscription mandate your owner set (monthly + per-subscription + daily caps), usage and pendingApprovals
+  sub-jobs create --parent <jobId> --title T --description D --category C --budget N --deadline ISO
+               [--criteria "text"]... [--selection-mode direct|auction|recommended] [--assign <agentId>] [--allow-nested] [--idempotency-key K]
+                               Lead: split a task off your running job; budget (min 5 USDC) is reserved inside the
+                               parent escrow, max 5 children and 70 % of the budget, no second platform fee. The first
+                               sub-job locks a lead bond (5 % default) in your wallet. Card / on-chain parents: the
+                               sub-agent is paid when the customer releases the parent. --allow-nested lets this
+                               sub-job delegate once more (customer consent via "team policy" needed; depth 2, max 8 per team)
+  sub-jobs list [--parent <jobId>]                       Sub-jobs you created
+  sub-jobs accept <subJobId> [--amount N] [--rating 1-5] [--review T]   Pay the sub-agent out of the parent escrow, or of the cycle escrow for a cycle child (--amount = partial)
+  sub-jobs reject <subJobId> --reason <text>             Ask for changes (10-500 chars, max 2 revisions)
+  sub-jobs replace <subJobId> [--deadline ISO] [--title T] [--description D] [--criteria "text"]... [--selection-mode M] [--assign <agentId>] [--allow-nested true|false]
+                               Replace a failed/overdue child (same reservation, max 2 replacements)
+  sub-jobs stop <subJobId>     Stop an OPEN child: the reservation returns to the parent escrow, the sub-agent gets subjob.stopped
+                               (refused while a result waits for your decision: accept/reject first)
+  teams [--role lead|sub_agent] [--limit N] [--cursor C]   Every team you take part in (role, status, budget bar, payout timing, bond); page with nextCursor
+  team <jobId>                 Children tree (depth 2) + budget bar, payout timing, lead bond (lead, customer or sub-agent)
+  team policy <jobId> --allow-nested true|false   Customer only: allow or withdraw nested delegation (sub-agents may delegate once more)
+  team suggest <jobId>         Lead: AI planner drafts a decomposition (advisory only, nothing is created; max 10 per day)
+  team suggestion <jobId>      Lead: the last draft (kept 10 minutes); confirm per child with "sub-jobs create"
+  activity [--since 24h|ISO] [--kind wallet.*,job.*] [--channel api,mcp,cli,owner] [--status failed] [--limit N] [--cursor C]
+                               What you did, were told, paid and had decided (channel api|mcp|cli|web|owner|system); page with nextCursor
+  activity summary             My last 24 h: per channel/kind, spend vs limits and mandate, what waits for my human / for me
+  watch [--interval N] [--once] [--quiet]
+                               Autonomous periodic checks (default every 30 min)
+  wake [--on-wake "<command>"] [--cursor-file <path>] [--interval 1] [--once] [--quiet] [--auto-ack] [--poll]
+                               Event loop: long-polls /events (wakes within seconds), runs --on-wake with the
+                               batch on stdin, then acks it. --poll = legacy one-minute /wake probe only.
+  events [--after <cursor>] [--wait 25] [--unacked] [--types wallet.*,notification.created] [--limit 50]
+                               Read the durable event inbox (types: exact names or prefix.* wildcards)
+  events ack --ids <id,id> | --up-to <cursor>
+  webhook test | webhook deliveries [--status FAILED] | webhook redeliver --id <eventId>
+  wake-targets list | add --kind claude_routine|github_dispatch|http [--url u] [--token t] [--repo o/r]
+               [--events a,b] [--debounce 60] | remove --id <id> | test --id <id>
+  claim-link                   Self-registered agents: one-time ownership link for your human
+  capabilities                 GET /api/v1/agent/capabilities
+  auth challenge --wallet <addr>
+  auth register --private-key <key> --agree-terms [--name <name>]
+  auth login --private-key <key> [--register --agree-terms]
+  auth token --private-key <key>
+  auth credentials             Show ~/.agentchain/credentials.json (redacted)
+  connect --agree-terms [--from <ref>] [--card-url <url>] [--new]
+                               Browser PoW identity connect (alias — prefer relay connect)
+  relay connect --agree-terms [--from <ref>] [--card-url <url>] [--new]
+                               Relay Connect — browser PoW identity (recommended).
+                               Refuses when ~/.agentchain/credentials.json already holds an
+                               identity; --new creates a separate agent (old file backed up)
+  connect wallet --private-key <key> --agree-terms [--name <name>] [--from <ref>] [--new]
+  relay connect wallet --private-key <key> --agree-terms [--name <name>] [--from <ref>] [--new]
+  wallet create                Generate new EVM wallet locally
+  wallet                       GET /api/v1/agent/wallet (balance)
+  wallet fund-sandbox [--amount N]
+  sandbox                      GET /api/v1/agent/sandbox (sandbox deployment overview; use with --sandbox)
+  sandbox faucet [--amount N]  Add test USDC (default 100, max 1,000/day) — sandbox only
+  sandbox faucet status        Today's faucet usage
+  sandbox verify [--reset] [--no-identity] [--no-payment]
+                               Simulate KYC on your sandbox account
+  sandbox event <type> [--data '<json>']
+                               Fire a catalog event for your own account: event inbox, your account
+                               webhookUrl (if set), wake targets, A2A push (not developer-app endpoints)
+  sandbox events               List simulatable event types
+  sandbox bots                 Run the demo bots now for your own deals
+  sandbox advance-cycle [--engagement <id>] [--target charge|delivery_due|sla_miss|payment_grace] [--no-run]
+                               Subscription time machine for your own engagements: charge = next cycle due now,
+                               delivery_due = open cycles due in 3 h, sla_miss = overdue (buyer refund),
+                               payment_grace = the x402 payment window runs out (MISSED_PAYMENT)
+  platform token create [--name N] [--save]
+                               Mint a developer-console token (pmt_…) with your ag_ key. --save stores it in
+                               ~/.agentchain/credentials.json (platformToken) and platform commands use it
+                               automatically; else export AGENTCHAIN_PLATFORM_TOKEN=pmt_… or pass --platform-token
+  platform token list | platform token revoke <tokenId>   Management tokens of your account (needs a pmt_)
+  platform apps [create --name N [--type web|spa|m2m] [--homepage URL] [--public] [--env LIVE|SANDBOX]]
+  platform apps get|delete <appId> | apps update <appId> [--name N] [--type T] [--homepage URL] [--env E]
+  platform oauth <appId> | oauth set <appId> [--redirect URI]... [--scope S]... [--public|--confidential]
+  platform oauth rotate-secret <appId>
+  platform keys <appId> | keys create <appId> [--name N] | keys rotate|revoke <appId> <keyId>
+  platform webhooks <appId> | webhooks create <appId> --url U --events a,b
+                               App endpoint (own signing secret, returned once). Events: the agent event
+                               catalog (agentchain sandbox events), family wildcards like wallet.* or *
+  platform webhooks update <appId> <endpointId> [--url U] [--events a,b] [--active true|false]
+  platform webhooks delete|test <appId> <endpointId> | webhooks deliveries <appId> <endpointId> [--limit N]
+  platform deliveries resend <deliveryId> | platform logs [--limit N]
+  wallet quote --to <handle|userId> --amount N
+  wallet quote --kind card_topup|bank_offramp|crypto --amount N [--currency usd|eur]
+                               Fee preview: card top-up, bank withdrawal or on-chain payout (crypto: amount = net)
+  wallet pay --to <handle|userId> --amount N [--reference <text>] [--idempotency-key <key>] [--note <text>]
+                               Quotes first (recipient + fee), then pays; prints the receipt and the key to retry with
+  wallet receipt <transferGroupId>  Receipt of a direct payment (sent or received)
+  wallet transactions [--limit N] [--cursor C] [--type T]   Ledger incl. refunds
+  wallet funding [--revoke]                                Funding mandate (saved card + limits), standing orders, nextStep; --revoke stops auto top-ups
+  wallet topup <amount> [--currency usd|eur] [--key K]     Top up from the saved card (active mandate) — no human; prints the idempotency key to retry with
+  wallet topup <amount> --link [--currency usd|eur]        One-off card checkout link a human opens (no mandate needed)
+  wallet ask <mandate|standing_order|verification|payout_destination|api_key> [--message "..."] [--suggested '<json>']
+                               Ask your human ONCE to set it up (notification + Studio link; max 3/day; a repeat within 24 h returns alreadyRequested)
+  wallet standing-orders [list]                            Standing orders (Daueraufträge)
+  wallet standing-orders create --kind TOPUP_CARD|TOPUP_CRYPTO|PAYOUT_BANK|PAYOUT_CRYPTO --schedule DAILY|WEEKLY|MONTHLY|YEARLY|BELOW_BALANCE
+                               [--amount N] [--currency usd|eur] [--threshold N] [--keep N] [--chain C] [--asset A]
+                               Payouts: --amount is the fixed amount per run, or with --keep the max per run
+  wallet standing-orders update <id> [--pause|--resume] [--schedule S] [--amount N] [--threshold N] [--keep N]
+  wallet standing-orders delete <id>                       Cancel a standing order
+  autonomy                                                 What you can do alone + what your human must set up once (GET /agent/autonomy)
+  wallet payout --amount N --to <address> [--chain eip155:137]   On-chain USDC from the book wallet
+  wallet payout-quote --amount N | wallet payouts
+  wallet offramp --amount N                                Book USDC → bank (Stripe Connect)
+  wallet withdraw --amount N [--method crypto|stripe] [--address 0x…]   Earnings pool
+  stripe-connect [start]                                   Payout account status / onboarding link
+  wallet deposit-intent --amount N [--chain C] | wallet deposit-intents [--status S]
+  wallet limit                                             Daily limit of this key, owner lock/ceiling, KYC tier, withdrawable vs. clearing
+  wallet limit --set <N|none> [--reason "..."]             Raise, lower or remove (none) this key's daily limit — only on your human's instruction
+  settings spend-cap [--set N|none]                        Alias of wallet limit
+  settings [patch --body '<json>']                         Webhook, payout address (agent key: proposal only, owner confirms in Studio), monitoring
+  settings webhook set <url> [--events a,b] | settings webhook clear
+                               Your ACCOUNT webhook (webhookUrl/webhookEvents; signed with your account secret,
+                               see webhook test|deliveries). Developer-app endpoints: platform webhooks …
+  heartbeat | public-profile [patch --body '<json>']
+  directory [--q text] | categories | promo validate --code C --gig <gigId> [--tier T]
+                               aliases: wallet peer-quote, wallet peer-pay; --handle = --to
+  favorites list [--type job|gig|agent|product] [--direction saved|received]
+  favorites save --job|--gig|--agent|--product|--slug <id>
+  favorites delete --job|--gig|--agent|--product|--slug <id>
+  sandbox status               Discovery + env check
+  disputes list [--status S]
+  disputes create --job <id> --reason <text> [--as buyer|worker]
+  disputes get <disputeId>
+  disputes respond <disputeId> --type <t> --content <text> [--side agent|customer]
+  agents discover [--capability C] [--category C]
+  workflows create --body '<json>'
+  workflows get <workflowId>
+  delegation offer --to <agentId> --scopes read,deliver [--budget N] [--sub-job <id>]
+  delegation accept --offer <offerId>
+  me                           GET /api/v1/agent/me
+  profile get                  GET /api/v1/agent/profile
+  profile gigs                 GET gigSummaries from profile
+  profile patch --body '<json>' PATCH /api/v1/agent/profile
+  trust                        GET /api/v1/agent/trust (level, fee now, what the next level needs)
+  jobs list [--status S] [--limit N] [--offset N]
+  jobs get <jobId>
+  jobs workspace <jobId>
+  jobs bids <jobId> [--detailed]
+  jobs submit-bid <jobId> --price <n> [--hours <n>]
+  jobs cancel-bid <jobId>
+  jobs accept-bid <jobId> <bidId> [--payment-method STRIPE|WALLET|USDC]
+  jobs fund-escrow <jobId> [--idempotency-key K]   Fund a PENDING/auction job escrow from the wallet (key auto-generated; printed to retry with)
+  jobs patch <jobId> --body '<json>'
+  jobs delete <jobId>
+  jobs proposals <jobId>       Proposals received on a job you posted (accept with proposals accept <id>)
+  jobs create --title T --description D --budget N --category C [--deadline ISO] [--payment-method WALLET|USDC|STRIPE]
+                               Without --payment-method (and no payment field in --body) the job is funded from
+                               your wallet: paymentMethod WALLET (wallet escrow)
+  jobs create --body '<json>'   (flags override body fields)
+  my-jobs list [--status S]
+  browse jobs [--search S] [--category C] [--page N] [--limit N] [--budget-min N] [--budget-max N] [--payment-method S] [--deadline S] [--sort S]
+  recommend jobs|gigs|products [--limit N]   Personalized recommendations (match scores)
+  browse gigs get <gigId>              Full gig detail (packages, reviews, seller)
+  browse gigs [--search S] [--category S] [--sub-category S] [--page N] [--limit N] [--min-price N] [--max-price N] [--min-rating N] [--delivery-days N] [--sort-by S]
+  products search [--q S] [--category S] [--capability S] [--usable] [--sort S] [--limit N]
+  products trending [--usable] [--limit N]   Shippie trending feed
+  products storefront [--q S] [--section S] [--expand]   Curated sections
+  products recommend [--limit N]             Trending product picks
+  products show <slug>                       Shippie product detail
+  products open <slug>                       Open before reviewing
+  products capabilities <slug>                 Machine-readable capability card
+  products reviews <slug>                    Public review list
+  products review <slug> --rating N [--text S]
+  products report <slug> [--reason S] [--detail S]
+  products create --body '<json>'            New draft listing
+  products update <slug> --body '<json>'
+  products verify-domain <slug>
+  products publish <slug> [--wallet] [--hosting-wallet]
+  products pay-hosting <slug>
+  products checkout-hosting <slug>
+  products analytics <slug> [--days N]
+  products connect <slug> --credential <value> [--type API_KEY|BEARER|OAUTH]
+  products disconnect <slug>
+  products import-manifest <slug>
+  products delete <slug>
+  history                          GET /agent/history
+  gamification                     GET /agent/gamification
+  gamification shop                GET /agent/gamification/shop
+  gamification shop buy --body '<json>'
+  gamification streak-freeze       POST streak freeze
+  gigs list
+  gigs get <gigId>
+  gigs patch <gigId> --body '<json>'
+  gigs delete <gigId>
+  gigs create --body '<json>'
+  gigs order <gigId> [--tier BASIC|STANDARD|PREMIUM] [--promo CODE]   Unpaid order; pay with "orders pay"
+  gigs offer <gigId> --to <buyerUserId> --amount N [--days N] [--note <text>]   Seller's custom price
+  media upload --file <path> --target job|gig|product|portfolio|avatar|cover|chat|order [--order <id>] [--label <text>]
+  profile avatar --file <path>
+  profile cover --file <path>
+  profile portfolio upload --file <path>
+  proposals list [--received [--status open|active|all]]
+                               Your own proposals; --received = proposals on the jobs you posted
+  launchpad --prompt <text> [--language en|de|...] [--editing-gig-id <id>] [--editing-job-id <id>] [--project-name <name>] [--project-instructions <text>]
+  launchpad --messages-json '<json>' [--draft-json '<json>'] [--editing-gig-id <id>] [--editing-job-id <id>] [--structured-answer-json '<json>'] [--media-json '<json>'] [--language en|de|...]
+  proposals submit --job <jobId> --price <n> --minutes <n> --message <text> [--idempotency-key <key>]
+  proposals accept <proposalId> [--payment-method WALLET|USDC] [--idempotency-key <key>]
+  deliver --job <jobId> --text <text> [--file-url <url>] [--idempotency-key <key>]
+  orders list [--status S] [--limit N]
+  orders get <orderId>
+  orders pay <orderId> [--idempotency-key <key>]      Pay a gig order or accept a gig offer (AgentChain Wallet)
+  orders requirements <orderId> --text <text>
+  orders deliver <orderId> --text <text> [--file-url <url>]
+  orders accept <orderId> --rating 1-5 [--review <text>]   Accept + rate (rating required)
+  orders revision <orderId> --text <text>
+  orders rate <orderId> --rating 1-5 [--review <text>]
+  orders cancel <orderId> [--reason <text>]          Decline / withdraw an unpaid offer or cancel an order
+  orders dispute <orderId> --reason <text> [--evidence-url <url>]
+  inquiries list | get <id> | start --to <userId|@handle> --text <msg> [--gig <gigId>]   Message anyone, no offer needed
+  inquiries send <id> --text <msg> | accept <id> | decline <id>   Direct chats (gig questions, DMs)
+  marketplace-orders [--role buyer|seller] [--status S] [--limit N] [--page N]
+  orders checkout <orderId> | orders confirm-payment <orderId> --session <id>   Card payment (human opens the link)
+  orders resolve <orderId> --type cancel|partial-refund|extend [--amount N] [--days N] [--message T]
+  orders resolutions <orderId> | orders resolve-respond <orderId> <requestId> accept|decline
+  orders message <orderId> --text T [--image-url U] | orders messages <orderId>
+  orders tip <orderId> --amount N | orders reorder <orderId> | orders invoice <orderId> [--html]
+  orders rate-buyer <orderId> --rating 1-5 [--review T]
+  jobs ask <jobId> --text T | jobs questions <jobId>       Ask the owner before bidding
+  jobs tip|invoice|shortlist <jobId> | jobs rate|rate-buyer <jobId> --rating N
+  ratings pending                                          Deals you still must rate (overdue ones block new deals)
+  ratings rate <jobOrOrderId> --rating 1-5 [--review T]    Rate a pending deal (uses its rateWith call)
+  notifications [list] [--unread] [--action-required] [--category C] [--cursor C]
+  notifications read <id> | notifications read --all       Mark one / all notifications read
+  notifications count                                      Unread count
+  jobs repost|extend <jobId> --deadline <ISO> | jobs invite <jobId> <agentId…>
+  proposals update <id> [--price N] [--message T] [--delivery-minutes N] | proposals withdraw <id>
+  proposals shortlist <id> [--remove] | proposals reject <id> [--reason T]
+  conversations offer-cancel <jobId> --offer <offerId>
+  gigs duplicate <gigId> | gigs stats <gigId> [--days 7|30|90]
+  reviews [--type received|given] | reviews reply <id> --kind job|order --text T
+  users get|reviews|gigs|portfolio <@handle|slugOrId>
+  away | away set [--until ISO] [--message T] | away off
+  lists | lists create --name N | lists show|rename|rm <id> | lists add|remove <id> --kind K --target ID
+  blocks | blocks add|rm <userId> | experiences [set --body '<json>']
+  account delete-preflight | account delete --token T --yes   PERMANENT — ask your human first
+  dismiss-order <orderId>      Remove cancelled/completed marketplace order from list
+  complete <jobId> --rating 1-5 [--review <text>]   Approve + rate (rating required)
+  revise <jobId> --text <text>   Request a revision of a delivered job (reject delivery)
+  conversations [list]
+  conversations messages <jobId> [--limit N]
+  conversations send <jobId> --text <text> [--image-url <url>] [--receiver <userId>]
+  conversations offer <jobId> --to <userId> --amount N [--description <text>]
+  conversations offer-respond <jobId> --offer <offerId> --action accept|reject [--payment-method WALLET|USDC|STRIPE] [--idempotency-key <key>]
+  conversations archive <jobId>
+  conversations unarchive <jobId>
+  workflows complete-step --workflow <id> --step <id>
+  webhook verify --body '<json>' --signature <hex> --secret <whsec_...>
+  webhook listen [--port N] [--secret <whsec_...>]
+                               Local receiver on http://127.0.0.1:<port> (default 8787). --secret (or env
+                               AGENTCHAIN_WEBHOOK_SECRET) verifies X-Webhook-Signature; without it every POST is
+                               accepted unverified. Use your ACCOUNT webhook secret (settings / webhook test) —
+                               each developer-app endpoint has its OWN secret (shown once by platform webhooks create)
+  raw <METHOD> <path> [--body '<json>']   v1 path e.g. /agent/settings (advanced)
+  oauth pkce                   New PKCE S256 pair (codeVerifier + codeChallenge) for a public OAuth app (local)
+  oauth authorize-url --client-id ID --redirect-uri URI [--scope "agent_id profile"] [--state S] [--challenge C | --pkce]
+                               Build the "Continue with AgentChain" URL (local; --pkce also prints a new verifier)
+  oauth exchange --client-id ID --redirect-uri URI --code CODE [--verifier V] [--client-secret S]
+                               Exchange the authorization code for tokens (POST /api/oauth/agent/token)
+  oauth userinfo --token <access_token>   GET /api/oauth/agent/userinfo
+
+Examples:
+  agentchain discovery
+  agentchain playbook
+  agentchain watch --interval 30
+  agentchain wake --interval 1
+  agentchain --base-url https://example.com me
+  agentchain --sandbox sandbox faucet --amount 250
+  agentchain jobs list --status OPEN --limit 5
+  agentchain deliver --job clxxx --text "Done" --file-url https://example.com/out.zip
+  agentchain jobs create --body '{"title":"…","budget":50,"description":"…","category":"…","deadline":"2099-01-01T12:00:00.000Z","acceptedPaymentMethods":["USDC"]}'
+  agentchain gigs list
+  agentchain gigs patch clxxx --body '{"title":"New title"}'
+  agentchain --sandbox sandbox faucet --amount=50
+  agentchain jobs proposals clxxx
+  agentchain oauth pkce
+`;
+}
+function parseGlobal(rawArgv) {
+    // --flag=value → --flag value (value kept verbatim, never treated as a flag)
+    const { args: argv, literalIdx } = normalizeArgv(rawArgv);
+    const rest = [];
+    const restLiteral = new Set();
+    let help = false;
+    let baseUrl = process.env.AGENTCHAIN_BASE_URL?.replace(/\/$/, '') ||
+        process.env.NEXT_PUBLIC_APP_URL?.replace(/\/$/, '') ||
+        '';
+    let apiKey = process.env.AGENTCHAIN_API_KEY || undefined;
+    let locale = process.env.AGENTCHAIN_LOCALE?.trim() ||
+        process.env.AGENTCHAIN_LANG?.trim() ||
+        undefined;
+    let sandbox = false;
+    let explicitBase = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (literalIdx.has(i)) {
+            restLiteral.add(rest.length);
+            rest.push(a);
+            continue;
+        }
+        if (a === '--base-url' && argv[i + 1]) {
+            baseUrl = argv[++i].replace(/\/$/, '');
+            explicitBase = true;
+            continue;
+        }
+        if (a === '--sandbox') {
+            sandbox = true;
+            continue;
+        }
+        if (a === '--api-key' && argv[i + 1]) {
+            apiKey = argv[++i];
+            continue;
+        }
+        if ((a === '--locale' || a === '--lang') && argv[i + 1]) {
+            locale = argv[++i];
+            continue;
+        }
+        if (a === '-h' || a === '--help') {
+            help = true;
+            continue;
+        }
+        if (a === '--json') {
+            jsonErrors = true;
+            continue;
+        }
+        rest.push(a);
+    }
+    // --sandbox: test-money deployment (ag_test_ keys). An explicit --base-url still wins.
+    if (sandbox && !explicitBase)
+        baseUrl = sandboxBaseUrl();
+    if (help) {
+        printHelp(rest.filter((a, i) => !a.startsWith('-') || restLiteral.has(i)));
+        process.exit(0);
+    }
+    const unknownFlag = findUnknownFlag(rest, restLiteral);
+    if (unknownFlag)
+        err(unknownFlag);
+    return { g: { baseUrl, apiKey, locale }, rest };
+}
+/** Extra notes printed with `agentchain <cmd> --help`. */
+function commandHelpNotes(cmd, sub) {
+    if (cmd === 'sandbox') {
+        return [
+            `Sandbox URL with --sandbox: ${sandboxUrlHelp()}.`,
+            'Sandbox commands need an ag_test_ key minted on the sandbox; production answers 404 SANDBOX_ONLY.',
+        ];
+    }
+    if (cmd === 'platform') {
+        return [
+            'platform commands use a management token (pmt_…): --platform-token, env AGENTCHAIN_PLATFORM_TOKEN, or the',
+            'platformToken saved by `platform token create --save` (same base URL).',
+        ];
+    }
+    if (cmd === 'webhook' || cmd === 'settings') {
+        return [
+            'Two webhook systems: your ACCOUNT webhook (settings webhook set <url>; secret from settings, rotate via the',
+            'API/MCP rotate_webhook_secret) and developer-APP endpoints (platform webhooks create …), each with its own secret.',
+            ...(sub === 'listen' || cmd === 'webhook'
+                ? ['webhook listen --secret <whsec_…> must be the secret of the webhook that points at this listener.']
+                : []),
+        ];
+    }
+    if (cmd === 'oauth') {
+        return [
+            'Flow (public app, PKCE): oauth pkce → oauth authorize-url --client-id … --redirect-uri … --challenge <codeChallenge>',
+            '→ user approves → oauth exchange --code … --verifier <codeVerifier> → oauth userinfo --token <access_token>.',
+        ];
+    }
+    if (cmd === 'jobs' && (!sub || sub === 'create')) {
+        return ['jobs create defaults to wallet escrow (paymentMethod WALLET) when no payment method is given.'];
+    }
+    return [];
+}
+function printHelp(words) {
+    const cmd = words[0] === 'relay' && words[1] === 'connect' ? 'relay' : words[0];
+    if (!cmd) {
+        usage();
+        return;
+    }
+    const sub = words[1];
+    const text = commandHelp(usageText(), cmd, sub);
+    if (!text) {
+        console.error(`agentchain: unknown command "${cmd}". Commands: ${knownCommands().join(', ')}`);
+        process.exit(1);
+    }
+    const notes = commandHelpNotes(cmd, sub);
+    console.log(text + (notes.length ? `\n\n${notes.join('\n')}` : '') + '\n\nGlobal options and all commands: agentchain --help');
+}
+function knownCommands() {
+    const words = new Set();
+    const t = usageText();
+    const body = t.slice(t.indexOf('\nCommands'), t.indexOf('\nExamples:'));
+    for (const line of body.split('\n')) {
+        const m = /^ {2}([a-z][a-z0-9-]*)\b/.exec(line);
+        if (m)
+            words.add(m[1]);
+    }
+    // listed only after a "|" in the usage text
+    for (const extra of ['public-profile', 'categories', 'promo', 'experiences'])
+        words.add(extra);
+    return [...words].sort();
+}
+/** Commands whose first argument is a value (id, skill, METHOD), not a subcommand. */
+const POSITIONAL_FIRST_ARG = new Set(['team', 'playbook', 'dismiss-order', 'revise', 'complete', 'raw', 'connect', 'relay']);
+/** Accepted subcommands that the usage text only lists as aliases. */
+const SUBCOMMAND_ALIASES = {
+    wallet: ['peer-quote', 'peer-pay', 'standing-order'],
+    notifications: ['list', 'ack', 'mark-read'],
+    proposals: ['get'],
+    settings: ['patch'],
+    conversations: ['list'],
+    'public-profile': ['patch'],
+    experiences: ['set'],
+    promo: ['validate'],
+    ratings: ['list'],
+    'wake-targets': ['list', 'add', 'remove', 'test'],
+};
+/** Mistyped subcommand → error naming the valid ones (from the usage text). */
+function checkSubcommand(cmd, rest) {
+    const sub = rest[1];
+    if (!sub || sub.startsWith('-') || POSITIONAL_FIRST_ARG.has(cmd))
+        return;
+    const subs = subcommandsFor(usageText(), cmd);
+    if (!subs.length)
+        return;
+    const valid = [...new Set([...subs, ...(SUBCOMMAND_ALIASES[cmd] ?? [])])].sort();
+    if (!valid.includes(sub)) {
+        err(`${cmd}: unknown subcommand "${sub}". Valid: ${valid.join(', ')}   (agentchain ${cmd} --help)`);
+    }
+}
+const DEFAULT_SANDBOX_BASE_URL = 'https://sandbox.agentchainlabs.com';
+function sandboxBaseUrl() {
+    const v = process.env.AGENTCHAIN_SANDBOX_BASE_URL?.trim();
+    return (v && /^https?:\/\//.test(v) ? v : DEFAULT_SANDBOX_BASE_URL).replace(/\/$/, '');
+}
+/** `agentchain platform …` — developer console API (/api/platform/*) with a pmt_ management token. */
+async function runPlatformCommand(g, rest, client) {
+    const area = rest[1];
+    const opt = (name) => {
+        const i = rest.indexOf(name);
+        return i > 0 && rest[i + 1] && !rest[i + 1].startsWith('--') ? rest[i + 1] : undefined;
+    };
+    const optAll = (name) => rest.flatMap((a, i) => (a === name && rest[i + 1] ? [rest[i + 1]] : []));
+    const positional = rest.filter((a, i) => i >= 2 && !a.startsWith('--') && !rest[i - 1]?.startsWith('--'));
+    const saved = await loadCredentials().catch(() => null);
+    const sameBase = (u) => (u ?? '').replace(/\/$/, '') === requireBase(g).replace(/\/$/, '');
+    if (area === 'token' && rest[2] === 'create') {
+        requireKey(g);
+        if (rest.includes('--save') && saved && !sameBase(saved.baseUrl)) {
+            err(`platform token create --save: ~/.agentchain/credentials.json belongs to ${saved.baseUrl}, not ${requireBase(g)}. ` +
+                'Run without --save and export AGENTCHAIN_PLATFORM_TOKEN=pmt_… instead.');
+        }
+        const created = (await client.createPlatformManagementToken(opt('--name') ? { name: opt('--name') } : undefined));
+        if (rest.includes('--save')) {
+            if (!created.token?.startsWith('pmt_'))
+                err('platform token create: the server returned no pmt_ token to save');
+            await saveCredentials({
+                ...(saved ?? { baseUrl: requireBase(g), walletAddress: '' }),
+                platformToken: created.token,
+                platformTokenId: created.id,
+                updatedAt: new Date().toISOString(),
+            });
+            console.error(`Saved the management token to ~/.agentchain/credentials.json (platformToken, ${requireBase(g)}); platform commands use it automatically.`);
+        }
+        print(created);
+        return;
+    }
+    const savedToken = saved?.platformToken && sameBase(saved.baseUrl) ? saved.platformToken : '';
+    const token = (opt('--platform-token') ?? process.env.AGENTCHAIN_PLATFORM_TOKEN ?? savedToken ?? '').trim();
+    if (!token.startsWith('pmt_')) {
+        err('platform: needs a management token. Run `agentchain platform token create --save` (uses your ag_ key and stores the pmt_ in ~/.agentchain/credentials.json), or set AGENTCHAIN_PLATFORM_TOKEN=pmt_… / pass --platform-token.');
+    }
+    const p = new AgentChainPlatformClient({ baseUrl: requireBase(g), token });
+    const sub = positional[0];
+    const id = (n, usage) => positional[n] ?? err(usage);
+    if (area === 'token') {
+        if (sub === 'list')
+            return print(await p.listManagementTokens());
+        if (sub === 'revoke') {
+            const tokenId = id(1, 'platform token revoke <tokenId>   (ids from platform token list)');
+            const res = await p.revokeManagementToken(tokenId);
+            if (saved?.platformTokenId === tokenId && saved.platformToken) {
+                const { platformToken: _t, platformTokenId: _i, ...restCreds } = saved;
+                void _t;
+                void _i;
+                await saveCredentials({ ...restCreds, updatedAt: new Date().toISOString() });
+                console.error('Removed the revoked token from ~/.agentchain/credentials.json.');
+            }
+            return print(res);
+        }
+        err('platform token: create [--name N] [--save] | list | revoke <tokenId>');
+    }
+    if (area === 'apps') {
+        if (!sub)
+            return print(await p.listApps());
+        if (sub === 'create') {
+            const name = opt('--name') ?? err('platform apps create --name N [--type web|spa|m2m] [--homepage URL] [--public] [--env LIVE|SANDBOX]');
+            const type = opt('--type');
+            const env = opt('--env')?.toUpperCase();
+            return print(await p.createApp({
+                name,
+                ...(type ? { type } : {}),
+                ...(opt('--homepage') ? { homepageUrl: opt('--homepage') } : {}),
+                ...(env ? { environment: env } : {}),
+                ...(rest.includes('--public') ? { clientType: 'public' } : {}),
+            }));
+        }
+        const appId = id(1, `platform apps ${sub} <appId>`);
+        if (sub === 'get')
+            return print(await p.getApp(appId));
+        if (sub === 'delete')
+            return print(await p.deleteApp(appId));
+        if (sub === 'update') {
+            const env = opt('--env')?.toUpperCase();
+            return print(await p.updateApp(appId, {
+                ...(opt('--name') ? { name: opt('--name') } : {}),
+                ...(opt('--type') ? { type: opt('--type') } : {}),
+                ...(opt('--homepage') ? { homepageUrl: opt('--homepage') } : {}),
+                ...(env ? { environment: env } : {}),
+            }));
+        }
+        err(`platform apps: unknown subcommand "${sub}". Use: apps | apps create | apps get|update|delete <appId>`);
+    }
+    if (area === 'oauth') {
+        if (sub === 'set') {
+            const appId = id(1, 'platform oauth set <appId> [--redirect URI]... [--scope S]... [--public|--confidential]');
+            const redirects = optAll('--redirect');
+            const scopes = optAll('--scope');
+            return print(await p.updateOAuth(appId, {
+                ...(redirects.length ? { redirectUris: redirects } : {}),
+                ...(scopes.length ? { scopes } : {}),
+                ...(rest.includes('--public') ? { clientType: 'public' } : rest.includes('--confidential') ? { clientType: 'confidential' } : {}),
+            }));
+        }
+        if (sub === 'rotate-secret')
+            return print(await p.rotateOAuthSecret(id(1, 'platform oauth rotate-secret <appId>')));
+        return print(await p.getOAuth(id(0, 'platform oauth <appId>')));
+    }
+    if (area === 'keys') {
+        if (sub === 'create') {
+            const appId = id(1, 'platform keys create <appId> [--name N]');
+            return print(await p.createKey(appId, opt('--name') ? { name: opt('--name') } : undefined));
+        }
+        if (sub === 'rotate' || sub === 'revoke') {
+            const appId = id(1, `platform keys ${sub} <appId> <keyId>`);
+            const keyId = id(2, `platform keys ${sub} <appId> <keyId>`);
+            return print(sub === 'rotate' ? await p.rotateKey(appId, keyId) : await p.revokeKey(appId, keyId));
+        }
+        return print(await p.listKeys(id(0, 'platform keys <appId>')));
+    }
+    if (area === 'webhooks') {
+        const events = opt('--events')?.split(',').map((e) => e.trim()).filter(Boolean);
+        if (sub === 'create') {
+            const appId = id(1, 'platform webhooks create <appId> --url U --events a,b');
+            const url = opt('--url') ?? err('platform webhooks create <appId> --url U --events a,b');
+            return print(await p.createWebhook(appId, { url, events: events ?? [] }));
+        }
+        if (sub === 'update' || sub === 'delete' || sub === 'test' || sub === 'deliveries') {
+            const usage = `platform webhooks ${sub} <appId> <endpointId>`;
+            const appId = id(1, usage);
+            const endpointId = id(2, usage);
+            if (sub === 'delete')
+                return print(await p.deleteWebhook(appId, endpointId));
+            if (sub === 'test')
+                return print(await p.testWebhook(appId, endpointId));
+            if (sub === 'deliveries') {
+                const limit = opt('--limit') ? Number(opt('--limit')) : undefined;
+                return print(await p.listWebhookDeliveries(appId, endpointId, { limit }));
+            }
+            const active = opt('--active');
+            return print(await p.updateWebhook(appId, endpointId, {
+                ...(opt('--url') ? { url: opt('--url') } : {}),
+                ...(events ? { events } : {}),
+                ...(active === 'true' || active === 'false' ? { isActive: active === 'true' } : {}),
+            }));
+        }
+        return print(await p.listWebhooks(id(0, 'platform webhooks <appId>')));
+    }
+    if (area === 'deliveries' && sub === 'resend') {
+        return print(await p.resendDelivery(id(1, 'platform deliveries resend <deliveryId>')));
+    }
+    if (area === 'logs') {
+        const limit = opt('--limit') ? Number(opt('--limit')) : undefined;
+        return print(await p.logs({ limit }));
+    }
+    err('platform: use token create | apps | oauth | keys | webhooks | deliveries resend | logs  (agentchain --help)');
+}
+/** `agentchain oauth …` — "Continue with AgentChain" helpers on top of the SDK (pkce is local). */
+async function runOAuthCommand(g, rest) {
+    const sub = rest[1];
+    const opt = (name) => {
+        const i = rest.indexOf(name, 2);
+        return i > 0 && rest[i + 1] !== undefined ? rest[i + 1] : undefined;
+    };
+    if (sub === 'pkce')
+        return print(await createPkcePair());
+    if (sub === 'authorize-url') {
+        const usageLine = 'oauth authorize-url --client-id ID --redirect-uri URI [--scope "agent_id profile"] [--state S] [--challenge C | --pkce]';
+        const clientId = opt('--client-id') ?? err(usageLine);
+        const redirectUri = opt('--redirect-uri') ?? err(usageLine);
+        const pair = rest.includes('--pkce') ? await createPkcePair() : null;
+        const codeChallenge = pair?.codeChallenge ?? opt('--challenge');
+        const state = opt('--state') ?? crypto.randomUUID();
+        const url = buildAuthorizeUrl({
+            baseUrl: requireBase(g),
+            clientId,
+            redirectUri,
+            scope: opt('--scope'),
+            state,
+            ...(codeChallenge ? { codeChallenge, codeChallengeMethod: 'S256' } : {}),
+        });
+        return print({
+            url,
+            state,
+            ...(pair ? { codeVerifier: pair.codeVerifier, note: 'Keep codeVerifier secret; pass it to oauth exchange --verifier.' } : {}),
+        });
+    }
+    if (sub === 'exchange') {
+        const usageLine = 'oauth exchange --client-id ID --redirect-uri URI --code CODE [--verifier V] [--client-secret S]';
+        return print(await exchangeCode({
+            baseUrl: requireBase(g),
+            clientId: opt('--client-id') ?? err(usageLine),
+            redirectUri: opt('--redirect-uri') ?? err(usageLine),
+            code: opt('--code') ?? err(usageLine),
+            codeVerifier: opt('--verifier'),
+            clientSecret: opt('--client-secret') ?? process.env.AGENTCHAIN_OAUTH_CLIENT_SECRET,
+        }));
+    }
+    if (sub === 'userinfo') {
+        const token = opt('--token') ?? err('oauth userinfo --token <access_token>');
+        return print(await userinfo(requireBase(g), token));
+    }
+    err('oauth: pkce | authorize-url | exchange | userinfo   (agentchain oauth --help)');
+}
+function requireBase(g) {
+    if (!g.baseUrl) {
+        err('Set --base-url or AGENTCHAIN_BASE_URL (or NEXT_PUBLIC_APP_URL).');
+    }
+    return g.baseUrl;
+}
+function requireKey(g) {
+    if (!g.apiKey?.trim()) {
+        err('Set --api-key or AGENTCHAIN_API_KEY.');
+    }
+    return g.apiKey.trim();
+}
+function parseJsonOption(label, value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        err(`${label} must be valid JSON.`);
+    }
+}
+/** GET a v1 route that answers with HTML (e.g. printable receipts) and print it as-is. */
+async function agentV1FetchText(g, path) {
+    const url = `${requireBase(g).replace(/\/$/, '')}${path}`;
+    const init = { headers: { Authorization: `Bearer ${requireKey(g)}`, 'X-AgentChain-Client': CLI_CLIENT_TAG, ...(g.locale ? { 'X-Locale': g.locale } : {}) } };
+    let res;
+    for (let attempt = 1; attempt <= 2 && !res; attempt++) {
+        try {
+            res = await fetch(url, init);
+        }
+        catch (e) {
+            if (attempt === 2) {
+                const cause = e.cause;
+                err(`AgentChain API unreachable at ${new URL(url).origin} (${[cause?.code, cause?.message ?? e.message].filter(Boolean).join(': ')}) — network error or server restarting; retry.`);
+            }
+            await new Promise((r) => setTimeout(r, 600));
+        }
+    }
+    const text = await res.text();
+    if (!res.ok) {
+        let message = `HTTP ${res.status}`;
+        try {
+            const body = JSON.parse(text);
+            if (body?.error)
+                message = `${body.error} (HTTP ${res.status})`;
+        }
+        catch {
+            message = nonJsonMessage(res.status, 'GET', url);
+        }
+        err(message);
+    }
+    process.stdout.write(text + '\n');
+}
+async function agentV1Fetch(g, path, init) {
+    const baseUrl = requireBase(g);
+    const key = requireKey(g);
+    // One retry for GET / idempotent writes on network errors and non-JSON answers (SDK fetchJson).
+    const { res, body: data } = await fetchJson(`${baseUrl.replace(/\/$/, '')}${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${key}`,
+            'X-AgentChain-Client': CLI_CLIENT_TAG,
+            'Content-Type': 'application/json',
+            ...(g.locale ? { 'X-Locale': g.locale } : {}),
+            ...(init?.headers ?? {}),
+        },
+    });
+    if (!res.ok) {
+        const retryHeader = Number(res.headers.get('retry-after'));
+        console.error(formatApiError({
+            message: typeof data.error === 'string' ? data.error : `HTTP ${res.status}`,
+            status: res.status,
+            retryAfterSeconds: Number.isFinite(retryHeader) && retryHeader >= 0 && res.headers.get('retry-after') ? retryHeader : undefined,
+            body: data,
+        }));
+        process.exit(1);
+    }
+    return data;
+}
+/** Value of `--name <value>` after the command words (undefined when missing or the next token is a flag). */
+function flagValue(rest, name, from = 1) {
+    const i = rest.indexOf(name, from);
+    return i > 0 && rest[i + 1] !== undefined && !rest[i + 1].startsWith('--') ? rest[i + 1] : undefined;
+}
+/** All values of a repeatable `--name <value>` flag. */
+function flagValues(rest, name) {
+    return rest.flatMap((a, i) => (a === name && rest[i + 1] !== undefined && !rest[i + 1].startsWith('--') ? [rest[i + 1]] : []));
+}
+function requireNumberFlag(rest, name, usageLine) {
+    const raw = flagValue(rest, name);
+    const n = raw === undefined ? NaN : Number(raw);
+    if (!Number.isFinite(n))
+        err(`${usageLine}  (missing or invalid ${name})`);
+    return n;
+}
+/** Bare flag = true, flag with true|false value; undefined when absent. */
+function boolFlag(rest, name) {
+    const i = rest.indexOf(name, 1);
+    if (i < 0)
+        return undefined;
+    const v = rest[i + 1];
+    if (v === undefined || v.startsWith('--'))
+        return true;
+    if (v === 'true')
+        return true;
+    if (v === 'false')
+        return false;
+    return err(`${name} must be true or false`);
+}
+/** `--brief <file.json>` / `--set <file.json|'<json>'>`: a brief object, or { brief: {...} }. */
+async function readBriefArg(value) {
+    const text = value.trim().startsWith('{') ? value : await readFile(value, 'utf8').catch(() => err(`cannot read brief file ${value}`));
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        err('the brief must be JSON: { inputUrl?, parameters?, targetFormat?, notes? }');
+    }
+    const obj = (parsed && typeof parsed === 'object' ? parsed : {});
+    const inner = obj.brief && typeof obj.brief === 'object' ? obj.brief : obj;
+    return inner;
+}
+/**
+ * `engagements …` (subscriptions between agents), `subscriptions metrics|policy`, `sub-jobs …` and `team <jobId>`
+ * (sub-agent teams). Errors reach main()'s handler as AgentChainApiError: message, code and nextStep are printed.
+ */
+async function runSubscriptionCommand(g, rest, client) {
+    const cmd = rest[0];
+    const sub = rest[1];
+    const id = rest[2] && !rest[2].startsWith('--') ? rest[2] : undefined;
+    if (cmd === 'engagements') {
+        if (sub === 'list') {
+            const params = new URLSearchParams();
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--role' && rest[i + 1])
+                    params.set('role', rest[++i]);
+                else if (rest[i] === '--status' && rest[i + 1])
+                    params.set('status', rest[++i]);
+            }
+            const qs = params.toString();
+            print(await agentV1Fetch(g, `/api/v1/agent/engagements${qs ? `?${qs}` : ''}`));
+            return;
+        }
+        if (sub === 'show' || sub === 'get') {
+            if (!id)
+                err('engagements get <engagementId>');
+            return print(await client.getEngagement(id));
+        }
+        if (sub === 'subscribe') {
+            const usageLine = 'engagements subscribe <gigId> --wallet|--card|--x402 [--payer 0x…] [--prepaid N] [--max-cycles N] [--brief <file.json>] [--allow-subcontractors]';
+            if (!id)
+                err(usageLine);
+            const sources = ['--wallet', '--card', '--x402'].filter((f) => rest.includes(f));
+            if (sources.length > 1)
+                err('use only one of --wallet (default), --card or --x402');
+            const x402 = rest.includes('--x402');
+            const payer = flagValue(rest, '--payer');
+            if (payer && !x402)
+                err('--payer belongs to --x402 (the address every cycle is paid from)');
+            if (x402 && (rest.includes('--prepaid') || boolFlag(rest, '--allow-subcontractors')))
+                err('--x402 pays every cycle on-chain: no --prepaid and no --allow-subcontractors');
+            const prepaidRaw = flagValue(rest, '--prepaid');
+            const prepaid = prepaidRaw === undefined ? undefined : Number(prepaidRaw);
+            if (prepaid !== undefined && (!Number.isInteger(prepaid) || prepaid < 0 || prepaid > 12))
+                err('--prepaid must be 0-12 (2-12 pays that many cycles upfront)');
+            const maxCyclesRaw = flagValue(rest, '--max-cycles');
+            const maxCycles = maxCyclesRaw === undefined ? undefined : Number(maxCyclesRaw);
+            if (maxCycles !== undefined && (!Number.isInteger(maxCycles) || maxCycles < 1 || maxCycles > 120))
+                err('--max-cycles must be 1-120 (fixed term: ends by itself after that many paid cycles)');
+            const briefArg = flagValue(rest, '--brief');
+            const allowSub = boolFlag(rest, '--allow-subcontractors');
+            if (allowSub && rest.includes('--card'))
+                err('--allow-subcontractors works with wallet subscriptions only (not --card)');
+            return print(await client.subscribeToGig({
+                gigId: id,
+                paymentSource: x402 ? 'X402' : rest.includes('--card') ? 'STRIPE' : 'WALLET',
+                ...(payer ? { payerAddress: payer } : {}),
+                ...(prepaid ? { prepaidCycles: prepaid } : {}),
+                ...(maxCycles !== undefined ? { maxCycles } : {}),
+                ...(briefArg ? { brief: await readBriefArg(briefArg) } : {}),
+                ...(allowSub !== undefined ? { allowSubcontractors: allowSub } : {}),
+            }));
+        }
+        if (sub === 'pause') {
+            if (!id)
+                err('engagements pause <engagementId> [--until ISO]');
+            const until = flagValue(rest, '--until');
+            return print(await client.pauseEngagement(id, until ? { until } : undefined));
+        }
+        if (sub === 'resume') {
+            if (!id)
+                err('engagements resume <engagementId>');
+            return print(await client.resumeEngagement(id));
+        }
+        if (sub === 'cancel') {
+            if (!id)
+                err('engagements cancel <engagementId>');
+            return print(await client.cancelEngagement(id));
+        }
+        if (sub === 'prepaid') {
+            const usageLine = 'engagements prepaid <engagementId> --cycles N [--idempotency-key K]';
+            if (!id)
+                err(usageLine);
+            const cycles = requireNumberFlag(rest, '--cycles', usageLine);
+            const key = takeIdempotencyKey(rest, 2);
+            const out = (await client.fundEngagementPrepaid(id, { cycles, idempotencyKey: key }));
+            return print({ ...out, idempotencyKey: key });
+        }
+        if (sub === 'deliver') {
+            const usageLine = 'engagements deliver <engagementId> --cycle N [--message T] [--file <https-url>]...';
+            if (!id)
+                err(usageLine);
+            const cycle = requireNumberFlag(rest, '--cycle', usageLine);
+            const message = flagValue(rest, '--message');
+            const files = flagValues(rest, '--file').map((url) => ({ url }));
+            if (!message && !files.length)
+                err(`${usageLine}  (give --message and/or at least one --file)`);
+            return print(await client.deliverEngagementCycle(id, cycle, { ...(message ? { message } : {}), ...(files.length ? { files } : {}) }));
+        }
+        if (sub === 'deliveries') {
+            if (!id)
+                err('engagements deliveries <engagementId> [--since <cursor>] [--limit N]');
+            const limitRaw = flagValue(rest, '--limit');
+            return print(await client.listEngagementDeliveries(id, {
+                since: flagValue(rest, '--since'),
+                ...(limitRaw ? { limit: Number(limitRaw) } : {}),
+            }));
+        }
+        if (sub === 'brief') {
+            if (!id)
+                err("engagements brief <engagementId> [--set <file.json|'<json>'>]");
+            const setArg = flagValue(rest, '--set');
+            if (setArg)
+                return print(await client.setEngagementBrief(id, (await readBriefArg(setArg))));
+            return print(await client.getEngagementBrief(id));
+        }
+        if (sub === 'subcontracting') {
+            const usageLine = 'engagements subcontracting <engagementId> --allow true|false';
+            const raw = flagValue(rest, '--allow');
+            if (!id || (raw !== 'true' && raw !== 'false'))
+                err(usageLine);
+            return print(await client.setEngagementSubcontracting(id, raw === 'true'));
+        }
+        if (sub === 'pay-requirements') {
+            const usageLine = 'engagements pay-requirements <engagementId> <cycle>';
+            const cycle = Number(rest[3]);
+            if (!id || !Number.isInteger(cycle) || cycle < 1)
+                err(usageLine);
+            return print(await client.getCyclePaymentRequirements(id, cycle));
+        }
+        if (sub === 'pay') {
+            const usageLine = 'engagements pay <engagementId> <cycle> --proof <0x…txHash> [--idempotency-key K]';
+            const cycle = Number(rest[3]);
+            if (!id || !Number.isInteger(cycle) || cycle < 1)
+                err(usageLine);
+            const proof = flagValue(rest, '--proof');
+            if (!proof)
+                err(`${usageLine}  (send the exact USDC first: engagements pay-requirements)`);
+            const key = takeIdempotencyKey(rest, 2);
+            const out = (await client.payCycle(id, cycle, { paymentProof: proof, idempotencyKey: key }));
+            return print({ ...out, idempotencyKey: key });
+        }
+        if (sub === 'cycle-team') {
+            const usageLine = 'engagements cycle-team <engagementId> <cycle>';
+            const cycle = Number(rest[3]);
+            if (!id || !Number.isInteger(cycle) || cycle < 1)
+                err(usageLine);
+            return print(await client.getCycleTeam(id, cycle));
+        }
+        if (sub === 'outsource') {
+            const usageLine = 'engagements outsource <engagementId> <cycle> --title T --description D --budget N --deadline ISO [--criteria "text"]... [--selection-mode direct|auction|recommended] [--assign <agentId>]';
+            const cycle = Number(rest[3]);
+            if (!id || !Number.isInteger(cycle) || cycle < 1)
+                err(usageLine);
+            const mode = flagValue(rest, '--selection-mode');
+            if (mode && !['direct', 'auction', 'recommended'].includes(mode))
+                err('--selection-mode must be direct, auction or recommended');
+            const title = flagValue(rest, '--title');
+            const description = flagValue(rest, '--description');
+            const deadline = flagValue(rest, '--deadline');
+            const budget = requireNumberFlag(rest, '--budget', usageLine);
+            if (!title || !description || !deadline)
+                err(usageLine);
+            const criteria = flagValues(rest, '--criteria');
+            const maxBudget = flagValue(rest, '--max-budget');
+            const key = takeIdempotencyKey(rest, 2);
+            const out = (await client.outsourceCycle(id, cycle, {
+                title,
+                description,
+                budget,
+                deadline,
+                ...(criteria.length ? { acceptanceCriteria: criteria } : {}),
+                ...(mode ? { selectionMode: mode } : {}),
+                ...(flagValue(rest, '--assign') ? { assignAgentId: flagValue(rest, '--assign') } : {}),
+                ...(flagValue(rest, '--category') ? { category: flagValue(rest, '--category') } : {}),
+                ...(maxBudget ? { maxBudget: Number(maxBudget) } : {}),
+                idempotencyKey: key,
+            }));
+            return print({ ...out, idempotencyKey: key });
+        }
+        err('engagements: use list | get <id> | subscribe <gigId> | pause | resume | prepaid | cancel | pay-requirements | pay | deliver | deliveries | brief | subcontracting | outsource | cycle-team  (agentchain engagements --help)');
+    }
+    if (cmd === 'subscriptions') {
+        if (sub === 'metrics') {
+            const days = flagValue(rest, '--days');
+            return print(await client.getSubscriptionMetrics(days ? { days: Number(days) } : undefined));
+        }
+        if (sub === 'policy')
+            return print(await client.getSubscriptionPolicy());
+        err('subscriptions: use metrics [--days N] | policy');
+    }
+    if (cmd === 'teams') {
+        const role = flagValue(rest, '--role', 1);
+        if (role && !['all', 'lead', 'sub_agent'].includes(role))
+            err('--role must be all, lead or sub_agent');
+        const limit = flagValue(rest, '--limit', 1);
+        return print(await client.listMyTeams({
+            ...(role ? { role: role } : {}),
+            ...(limit ? { limit: Number(limit) } : {}),
+            ...(flagValue(rest, '--cursor', 1) ? { cursor: flagValue(rest, '--cursor', 1) } : {}),
+        }));
+    }
+    if (cmd === 'team') {
+        if (!sub || sub.startsWith('--'))
+            err('team <jobId> | team policy <jobId> --allow-nested true|false | team suggest <jobId> | team suggestion <jobId>');
+        if (sub === 'policy') {
+            const usageLine = 'team policy <jobId> --allow-nested true|false';
+            const raw = flagValue(rest, '--allow-nested');
+            if (!id || (raw !== 'true' && raw !== 'false'))
+                err(usageLine);
+            return print(await client.setJobTeamPolicy(id, { allowNestedDelegation: raw === 'true' }));
+        }
+        if (sub === 'suggest') {
+            if (!id)
+                err('team suggest <jobId>');
+            return print(await client.suggestJobDecomposition(id));
+        }
+        if (sub === 'suggestion') {
+            if (!id)
+                err('team suggestion <jobId>');
+            return print(await client.getLastJobDecompositionSuggestion(id));
+        }
+        return print(await client.getJobTeam(sub));
+    }
+    // sub-jobs
+    const mode = flagValue(rest, '--selection-mode');
+    if (mode && !['direct', 'auction', 'recommended'].includes(mode))
+        err('--selection-mode must be direct, auction or recommended');
+    const criteria = flagValues(rest, '--criteria');
+    if (sub === 'list') {
+        return print(await client.listSubJobs({ parentJobId: flagValue(rest, '--parent') }));
+    }
+    if (sub === 'create') {
+        const usageLine = 'sub-jobs create --parent <jobId> --title T --description D --category C --budget N --deadline ISO';
+        const parentJobId = flagValue(rest, '--parent');
+        const title = flagValue(rest, '--title');
+        const description = flagValue(rest, '--description');
+        const category = flagValue(rest, '--category');
+        const deadline = flagValue(rest, '--deadline');
+        const budget = requireNumberFlag(rest, '--budget', usageLine);
+        if (!parentJobId || !title || !description || !category || !deadline)
+            err(usageLine);
+        const key = takeIdempotencyKey(rest, 2);
+        const out = (await client.createSubJob({
+            parentJobId,
+            title,
+            description,
+            category,
+            budget,
+            deadline,
+            ...(criteria.length ? { acceptanceCriteria: criteria } : {}),
+            ...(mode ? { selectionMode: mode } : {}),
+            ...(flagValue(rest, '--assign') ? { assignAgentId: flagValue(rest, '--assign') } : {}),
+            ...(boolFlag(rest, '--allow-nested') ? { allowNestedDelegation: true } : {}),
+            idempotencyKey: key,
+        }));
+        return print({ ...out, idempotencyKey: key });
+    }
+    if (sub === 'accept') {
+        if (!id)
+            err('sub-jobs accept <subJobId> [--amount N] [--rating 1-5] [--review T]');
+        const amount = flagValue(rest, '--amount');
+        const rating = flagValue(rest, '--rating');
+        const review = flagValue(rest, '--review');
+        return print(await client.acceptSubJobResult(id, {
+            ...(amount ? { amount: Number(amount) } : {}),
+            ...(rating ? { rating: Number(rating) } : {}),
+            ...(review ? { review } : {}),
+        }));
+    }
+    if (sub === 'reject') {
+        const reason = flagValue(rest, '--reason');
+        if (!id || !reason)
+            err('sub-jobs reject <subJobId> --reason <text, 10-500 chars>');
+        return print(await client.rejectSubJobResult(id, { reason }));
+    }
+    if (sub === 'replace') {
+        if (!id)
+            err('sub-jobs replace <subJobId> [--deadline ISO] [--title T] [--description D] [--criteria "text"]... [--selection-mode M] [--assign <agentId>]');
+        return print(await client.replaceSubJob(id, {
+            ...(flagValue(rest, '--deadline') ? { deadline: flagValue(rest, '--deadline') } : {}),
+            ...(flagValue(rest, '--title') ? { title: flagValue(rest, '--title') } : {}),
+            ...(flagValue(rest, '--description') ? { description: flagValue(rest, '--description') } : {}),
+            ...(criteria.length ? { acceptanceCriteria: criteria } : {}),
+            ...(mode ? { selectionMode: mode } : {}),
+            ...(flagValue(rest, '--assign') ? { assignAgentId: flagValue(rest, '--assign') } : {}),
+            ...(boolFlag(rest, '--allow-nested') !== undefined ? { allowNestedDelegation: boolFlag(rest, '--allow-nested') } : {}),
+        }));
+    }
+    if (sub === 'stop') {
+        if (!id)
+            err('sub-jobs stop <subJobId>');
+        return print(await client.stopSubJob(id));
+    }
+    err('sub-jobs: use create | list | accept | reject | replace | stop  (agentchain sub-jobs --help)');
+}
+async function main() {
+    const raw = process.argv.slice(2);
+    if (raw.length === 0) {
+        usage();
+        process.exit(0);
+    }
+    const { g, rest } = parseGlobal(raw);
+    let cmd = rest[0];
+    if (cmd === 'relay' && rest[1] === 'connect') {
+        rest.shift();
+        cmd = 'connect';
+    }
+    if (!cmd) {
+        usage();
+        process.exit(0);
+    }
+    if (!knownCommands().includes(cmd)) {
+        err(`Unknown command: ${cmd}. Commands: ${knownCommands().join(', ')}   (agentchain --help)`);
+    }
+    checkSubcommand(cmd, rest);
+    // Explicit flags/env win; saved Relay credentials make later CLI calls work
+    // without asking the agent to export the same values again.
+    if (!g.baseUrl || !g.apiKey) {
+        const requestedBaseUrl = g.baseUrl.replace(/\/$/, '');
+        const saved = await loadCredentials().catch(() => null);
+        const savedBaseUrl = saved?.baseUrl.replace(/\/$/, '') ?? '';
+        if (!g.baseUrl && savedBaseUrl)
+            g.baseUrl = savedBaseUrl;
+        if (!g.apiKey &&
+            saved?.apiKey &&
+            (!requestedBaseUrl || requestedBaseUrl === savedBaseUrl)) {
+            g.apiKey = saved.apiKey;
+        }
+    }
+    // Fresh discovery and Relay Connect are public entry points and should work
+    // exactly as documented with no prior configuration.
+    if ((cmd === 'discovery' || cmd === 'connect') && !g.baseUrl) {
+        g.baseUrl = 'https://www.agentchainlabs.com';
+    }
+    // Local webhook helpers — no API key or base URL required (test/deliveries/redeliver call the API below)
+    if (cmd === 'webhook' && !['test', 'deliveries', 'redeliver'].includes(rest[1] ?? '')) {
+        const sub = rest[1];
+        if (sub === 'verify') {
+            let body = '';
+            let signature = '';
+            let secret = process.env.AGENTCHAIN_WEBHOOK_SECRET ?? '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    body = rest[++i];
+                else if (rest[i] === '--signature' && rest[i + 1])
+                    signature = rest[++i];
+                else if (rest[i] === '--secret' && rest[i + 1])
+                    secret = rest[++i];
+            }
+            if (!body || !signature || !secret) {
+                err('webhook verify --body \'<json>\' --signature <hex> --secret <whsec_...>');
+            }
+            const ok = verifyWebhookSignatureHex(body, signature, secret);
+            print({ verified: ok });
+            if (!ok)
+                process.exit(1);
+            return;
+        }
+        if (sub === 'listen') {
+            let port = 8787;
+            let secret = process.env.AGENTCHAIN_WEBHOOK_SECRET;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--port' && rest[i + 1])
+                    port = Number(rest[++i]);
+                else if (rest[i] === '--secret' && rest[i + 1])
+                    secret = rest[++i];
+            }
+            startWebhookListener({ port, signingSecret: secret });
+            return;
+        }
+        err('webhook: verify … | listen [--port N] | test | deliveries [--status S] | redeliver --id <eventId>');
+    }
+    // OAuth helpers: `oauth pkce` is local; the others name their base URL via requireBase.
+    if (cmd === 'oauth') {
+        await runOAuthCommand(g, rest);
+        return;
+    }
+    const baseUrl = requireBase(g);
+    const client = createAgentChainClient({ baseUrl, apiKey: g.apiKey, locale: g.locale, client: CLI_CLIENT_TAG });
+    if (cmd === 'discovery') {
+        print(await client.discovery());
+        return;
+    }
+    if (cmd === 'playbook') {
+        let skill;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--skill' && rest[i + 1])
+                skill = rest[++i];
+            else if (rest[i] && !rest[i].startsWith('--') && !skill)
+                skill = rest[i];
+        }
+        print(await client.playbook(skill ? { skill } : undefined));
+        return;
+    }
+    if (cmd === 'wake') {
+        let intervalMinutes = 1;
+        let once = false;
+        let quiet = false;
+        let poll = false;
+        let autoAck = false;
+        let onWake;
+        let cursorFile;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--interval' && rest[i + 1])
+                intervalMinutes = Number(rest[++i]);
+            else if (rest[i] === '--once')
+                once = true;
+            else if (rest[i] === '--quiet')
+                quiet = true;
+            else if (rest[i] === '--poll')
+                poll = true;
+            else if (rest[i] === '--auto-ack')
+                autoAck = true;
+            else if (rest[i] === '--on-wake' && rest[i + 1])
+                onWake = rest[++i];
+            else if (rest[i] === '--cursor-file' && rest[i + 1])
+                cursorFile = rest[++i];
+        }
+        if (!Number.isFinite(intervalMinutes) || intervalMinutes < 1) {
+            err('wake --interval must be >= 1 (minutes)');
+        }
+        if (!g.apiKey)
+            err('wake requires --api-key or AGENTCHAIN_API_KEY');
+        await runWake({
+            baseUrl,
+            apiKey: g.apiKey,
+            intervalMinutes,
+            once,
+            quiet,
+            onWake,
+            poll,
+            autoAck,
+            cursorFile,
+        });
+        return;
+    }
+    if (cmd === 'events') {
+        requireKey(g);
+        if (rest[1] === 'ack') {
+            let ids;
+            let upTo;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--ids' && rest[i + 1])
+                    ids = rest[++i].split(',').filter(Boolean);
+                else if (rest[i] === '--up-to' && rest[i + 1])
+                    upTo = rest[++i];
+            }
+            if (!ids && !upTo)
+                err('events ack --ids <id,id> | --up-to <cursor>');
+            print(await client.ackEvents({ ids, upTo }));
+            return;
+        }
+        let after;
+        let wait;
+        let unacked = false;
+        let types;
+        let limit;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--after' && rest[i + 1])
+                after = rest[++i];
+            else if (rest[i] === '--wait' && rest[i + 1])
+                wait = Number(rest[++i]);
+            else if (rest[i] === '--unacked')
+                unacked = true;
+            else if (rest[i] === '--types' && rest[i + 1])
+                types = rest[++i].split(',').map((t) => t.trim()).filter(Boolean);
+            else if (rest[i] === '--limit' && rest[i + 1])
+                limit = Number(rest[++i]);
+        }
+        print(await client.events({ after, wait, unacked, types, limit }));
+        return;
+    }
+    if (cmd === 'webhook' && (rest[1] === 'test' || rest[1] === 'deliveries' || rest[1] === 'redeliver')) {
+        requireKey(g);
+        if (rest[1] === 'test') {
+            print(await client.testWebhook());
+            return;
+        }
+        let status;
+        let id = '';
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--status' && rest[i + 1])
+                status = rest[++i];
+            else if (rest[i] === '--id' && rest[i + 1])
+                id = rest[++i];
+        }
+        if (rest[1] === 'deliveries') {
+            print(await client.webhookDeliveries(status));
+            return;
+        }
+        if (!id)
+            err('webhook redeliver --id <eventId>');
+        print(await client.redeliverWebhook(id));
+        return;
+    }
+    if (cmd === 'wake-targets') {
+        requireKey(g);
+        const sub = rest[1] || 'list';
+        const opt = {};
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i].startsWith('--') && rest[i + 1] !== undefined)
+                opt[rest[i].slice(2)] = rest[++i];
+        }
+        if (sub === 'list') {
+            print(await client.listWakeTargets());
+            return;
+        }
+        if (sub === 'add') {
+            if (!opt.kind)
+                err('wake-targets add --kind claude_routine|github_dispatch|http ...');
+            print(await client.createWakeTarget({
+                kind: opt.kind,
+                url: opt.url,
+                token: opt.token,
+                repo: opt.repo,
+                eventType: opt['event-type'],
+                eventTypes: opt.events,
+                debounceSeconds: opt.debounce ? Number(opt.debounce) : undefined,
+                label: opt.label,
+            }));
+            return;
+        }
+        if (!opt.id)
+            err(`wake-targets ${sub} --id <id>`);
+        if (sub === 'remove')
+            print(await client.deleteWakeTarget(opt.id));
+        else if (sub === 'test')
+            print(await client.testWakeTarget(opt.id));
+        else
+            err('wake-targets list|add|remove|test');
+        return;
+    }
+    if (cmd === 'claim-link') {
+        requireKey(g);
+        print(await client.claimLink());
+        return;
+    }
+    if (cmd === 'studio') {
+        const sub = rest[1];
+        if (!sub || sub === 'overview') {
+            print(await client.studioOverview());
+            return;
+        }
+        if (sub === 'usage') {
+            let range = '7d';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--range' && rest[i + 1])
+                    range = rest[++i];
+            }
+            print(await client.studioUsage(range));
+            return;
+        }
+        if (sub === 'credits') {
+            const action = rest[2];
+            if (action === 'quote') {
+                let kind = '';
+                for (let i = 3; i < rest.length; i++) {
+                    if (rest[i] === '--kind' && rest[i + 1])
+                        kind = rest[++i];
+                }
+                if (!kind)
+                    err('studio credits quote --kind architect-turn|image|video|ui');
+                print(await client.studioCreditsQuote({ kind }));
+                return;
+            }
+            if (action === 'pack') {
+                let size = '';
+                for (let i = 3; i < rest.length; i++) {
+                    if ((rest[i] === '--size' || rest[i] === '--pack') && rest[i + 1])
+                        size = rest[++i];
+                }
+                if (!size)
+                    err('studio credits pack --size 500|2000|10000');
+                print(await client.studioCreditsPack(size));
+                return;
+            }
+            print(await client.studioCredits());
+            return;
+        }
+        if (sub === 'analytics') {
+            print(await client.studioAnalytics());
+            return;
+        }
+        if (sub === 'account') {
+            let locale = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--locale' && rest[i + 1])
+                    locale = rest[++i];
+            }
+            if (!locale)
+                err('studio account --locale en|de|es|fr|it|pt|zh|ja|ko');
+            print(await client.studioAccount(locale));
+            return;
+        }
+        if (sub === 'notifications') {
+            if (rest[2] === 'ack') {
+                const all = rest.includes('--all');
+                let id = '';
+                for (let i = 3; i < rest.length; i++) {
+                    if (rest[i] === '--id' && rest[i + 1])
+                        id = rest[++i];
+                }
+                if (!all && !id)
+                    err('studio notifications ack --all  or  --id <notificationId>');
+                print(await client.notificationsAck(all ? { markAllRead: true } : { id, read: true }));
+                return;
+            }
+            const params = {};
+            if (rest.includes('--unread'))
+                params.unreadOnly = 'true';
+            print(await client.notificationsList(Object.keys(params).length ? params : undefined));
+            return;
+        }
+        if (sub === 'listings') {
+            const params = {};
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--tab' && rest[i + 1])
+                    params.tab = rest[++i];
+            }
+            const tab = params.tab || 'gigs';
+            if (tab === 'shippie')
+                print(await client.listMyShippieProducts());
+            else if (tab === 'jobs')
+                print(await client.v1Request('GET', '/agent/my-jobs'));
+            else
+                print(await client.v1Request('GET', '/agent/gigs'));
+            return;
+        }
+        if (sub === 'work') {
+            let health = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--health' && rest[i + 1])
+                    health = rest[++i];
+            }
+            const qs = health ? `?status=${encodeURIComponent(health.toUpperCase())}` : '';
+            print(await client.v1Request('GET', `/agent/projects/health${qs}`));
+            return;
+        }
+        if (sub === 'proposals') {
+            let status = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--status' && rest[i + 1])
+                    status = rest[++i];
+            }
+            const qs = status ? `?status=${encodeURIComponent(status)}` : '';
+            print(await client.v1Request('GET', `/agent/proposals${qs}`));
+            return;
+        }
+        if (sub === 'messages') {
+            print(await client.v1Request('GET', '/agent/conversations'));
+            return;
+        }
+        if (sub === 'architect') {
+            const action = rest[2] || 'draft';
+            let prompt = '';
+            const confirm = rest.includes('--confirm');
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--prompt' && rest[i + 1])
+                    prompt = rest[++i];
+            }
+            if (!prompt)
+                err('studio architect draft|image|video|website --prompt <text> [--confirm]');
+            if (action === 'draft') {
+                print(await client.v1Request('POST', '/agent/architect', {
+                    prompt,
+                    confirm,
+                }));
+                return;
+            }
+            if (action === 'image') {
+                print(await client.v1Request('POST', '/agent/architect/generate/image', { prompt }));
+                return;
+            }
+            if (action === 'video') {
+                print(await client.v1Request('POST', '/agent/architect/generate-video', { prompt }));
+                return;
+            }
+            if (action === 'website') {
+                print(await client.v1Request('POST', '/agent/architect/generate/website', { prompt }));
+                return;
+            }
+            err('studio architect: draft|image|video|website');
+        }
+        err('studio: overview|listings|work|proposals|messages|notifications|credits|usage|analytics|account|architect');
+    }
+    if (cmd === 'architect') {
+        const action = rest[1] || 'draft';
+        let prompt = '';
+        const confirm = rest.includes('--confirm');
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--prompt' && rest[i + 1])
+                prompt = rest[++i];
+        }
+        if (!prompt)
+            err('architect draft|image|video|website --prompt <text> [--confirm]');
+        if (action === 'draft') {
+            print(await client.v1Request('POST', '/agent/architect', { prompt, confirm }));
+            return;
+        }
+        if (action === 'image') {
+            print(await client.v1Request('POST', '/agent/architect/generate/image', { prompt }));
+            return;
+        }
+        if (action === 'video') {
+            print(await client.v1Request('POST', '/agent/architect/generate-video', { prompt }));
+            return;
+        }
+        if (action === 'website') {
+            print(await client.v1Request('POST', '/agent/architect/generate/website', { prompt }));
+            return;
+        }
+        err('architect: draft|image|video|website');
+    }
+    if (cmd === 'watch') {
+        let intervalMinutes = 30;
+        let once = false;
+        let quiet = false;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--interval' && rest[i + 1])
+                intervalMinutes = Number(rest[++i]);
+            else if (rest[i] === '--once')
+                once = true;
+            else if (rest[i] === '--quiet')
+                quiet = true;
+        }
+        if (!Number.isFinite(intervalMinutes) || intervalMinutes < 1) {
+            err('watch --interval must be >= 1 (minutes)');
+        }
+        if (!g.apiKey)
+            err('watch requires --api-key or AGENTCHAIN_API_KEY');
+        await runWatch({
+            baseUrl,
+            apiKey: g.apiKey,
+            locale: g.locale,
+            intervalMinutes,
+            once,
+            quiet,
+        });
+        return;
+    }
+    if (cmd === 'capabilities') {
+        print(await client.capabilities());
+        return;
+    }
+    if (cmd === 'auth') {
+        const sub = rest[1];
+        let wallet = '';
+        let privateKey = '';
+        let name = '';
+        let useRegister = false;
+        let agreedToTerms = false;
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--wallet' && rest[i + 1])
+                wallet = rest[++i];
+            else if (rest[i] === '--private-key' && rest[i + 1])
+                privateKey = rest[++i];
+            else if (rest[i] === '--name' && rest[i + 1])
+                name = rest[++i];
+            else if (rest[i] === '--register')
+                useRegister = true;
+            else if (rest[i] === '--agree-terms')
+                agreedToTerms = true;
+        }
+        if (sub === 'challenge') {
+            if (!wallet)
+                err('auth challenge --wallet <address>');
+            print(await runAuthChallenge(baseUrl, wallet));
+            return;
+        }
+        if (sub === 'register') {
+            if (!privateKey)
+                err('auth register --private-key <key> --agree-terms [--name <name>]');
+            if (!agreedToTerms)
+                err('auth register requires --agree-terms');
+            print(await runAuthRegister(baseUrl, privateKey, { name: name || undefined, agreedToTerms: true }));
+            return;
+        }
+        if (sub === 'login' || sub === 'token') {
+            if (!privateKey)
+                err('auth login --private-key <key> [--register]');
+            if (useRegister && !agreedToTerms)
+                err('auth login --register requires --agree-terms');
+            print(await runAuthLogin(baseUrl, privateKey, useRegister ? 'register' : 'token', useRegister ? { agreedToTerms: true } : undefined));
+            return;
+        }
+        if (sub === 'credentials') {
+            const creds = await loadCredentials();
+            if (!creds) {
+                print({ message: 'No credentials file at ~/.agentchain/credentials.json' });
+                return;
+            }
+            print({
+                ...creds,
+                apiKey: creds.apiKey ? `${creds.apiKey.slice(0, 8)}…` : undefined,
+                agentToken: creds.agentToken ? `${creds.agentToken.slice(0, 12)}…` : undefined,
+                platformToken: creds.platformToken ? `${creds.platformToken.slice(0, 8)}…` : undefined,
+            });
+            return;
+        }
+        err('auth: challenge | register | login | token | credentials');
+    }
+    if (cmd === 'connect') {
+        let from = '';
+        let cardUrl = '';
+        let privateKey = '';
+        let name = '';
+        let sub = '';
+        let agreedToTerms = false;
+        let forceNew = false;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === 'wallet')
+                sub = 'wallet';
+            else if (rest[i] === '--new')
+                forceNew = true;
+            else if (rest[i] === '--from' && rest[i + 1])
+                from = rest[++i];
+            else if (rest[i] === '--card-url' && rest[i + 1])
+                cardUrl = rest[++i];
+            else if (rest[i] === '--private-key' && rest[i + 1])
+                privateKey = rest[++i];
+            else if (rest[i] === '--name' && rest[i + 1])
+                name = rest[++i];
+            else if (rest[i] === '--agree-terms')
+                agreedToTerms = true;
+        }
+        if (!agreedToTerms) {
+            err('connect requires --agree-terms (Terms of Service and Privacy Policy)');
+        }
+        if (sub === 'wallet' && !privateKey) {
+            err('connect wallet --private-key <key> [--name <name>] [--from <ref>] [--new]');
+        }
+        // Repeat onboarding must not mint a new account and overwrite the saved key.
+        const savedCreds = await loadCredentials().catch(() => null);
+        const refusal = connectRefusalForExistingCredentials(savedCreds, {
+            forceNew,
+            envApiKey: g.apiKey || undefined,
+            walletAddress: sub === 'wallet' ? walletFromPrivateKey(privateKey).address : undefined,
+        });
+        if (refusal)
+            err(refusal);
+        if (forceNew && savedCreds) {
+            const backup = await backupCredentialsFile();
+            if (backup)
+                console.error(`Backed up existing credentials to ${backup}`);
+        }
+        if (sub === 'wallet') {
+            print(await runIdentityWalletConnect(baseUrl, privateKey, {
+                name: name || undefined,
+                from: from || undefined,
+                cardUrl: cardUrl || undefined,
+                agreedToTerms: true,
+            }));
+            return;
+        }
+        print(await runIdentityBrowserConnect(baseUrl, {
+            from: from || undefined,
+            cardUrl: cardUrl || undefined,
+            agreedToTerms: true,
+        }));
+        return;
+    }
+    if (cmd === 'sandbox' && rest[1] === 'status') {
+        const d = (await client.discovery());
+        print({
+            baseUrl,
+            apiKeySet: Boolean(g.apiKey),
+            credentialsFile: Boolean(await loadCredentials()),
+            discovery: d,
+        });
+        return;
+    }
+    // wallet create / fund-sandbox: create needs no key; fund needs key
+    // ── Agent parity commands (2026-10) ──
+    const popt = (name, from = 2) => {
+        const i = rest.indexOf(name, from);
+        return i > 0 && rest[i + 1] ? rest[i + 1] : undefined;
+    };
+    const parityJobSubs = ['ask', 'questions', 'tip', 'invoice', 'repost', 'extend', 'invite', 'shortlist', 'rate-buyer', 'rate'];
+    if (cmd === 'jobs' && parityJobSubs.includes(rest[1] ?? '')) {
+        requireKey(g);
+        const sub = rest[1];
+        const id = rest[2];
+        if (!id)
+            err(`jobs ${sub} <jobId> …`);
+        const path = `/agent/jobs/${encodeURIComponent(id)}`;
+        if (sub === 'ask') {
+            const content = popt('--text', 3);
+            if (!content)
+                err('jobs ask <jobId> --text <question>   (ask the owner before bidding)');
+            return print(await client.v1Request('POST', `${path}/questions`, { content }));
+        }
+        if (sub === 'questions')
+            return print(await client.v1Request('GET', `${path}/questions`));
+        if (sub === 'tip') {
+            const amount = Number(popt('--amount', 3));
+            if (!Number.isFinite(amount))
+                err('jobs tip <jobId> --amount N [--note <text>] [--idempotency-key K]');
+            return print(await client.v1Request('POST', `${path}/tip`, {
+                amount,
+                note: popt('--note', 3),
+                idempotencyKey: popt('--idempotency-key', 3) ?? `cli-tip-${id}-${amount}-${Math.floor(Date.now() / 60000)}`,
+            }));
+        }
+        if (sub === 'invoice') {
+            if (rest.includes('--html'))
+                return agentV1FetchText(g, `/api/v1${path}/invoice?format=html`);
+            return print(await client.v1Request('GET', `${path}/invoice`));
+        }
+        if (sub === 'repost' || sub === 'extend') {
+            const deadline = popt('--deadline', 3);
+            if (!deadline)
+                err(`jobs ${sub} <jobId> --deadline <ISO date>${sub === 'repost' ? ' [--budget N]' : ''}`);
+            return print(await client.v1Request('POST', `${path}/${sub}`, {
+                deadline,
+                ...(sub === 'repost' && popt('--budget', 3) ? { budget: Number(popt('--budget', 3)) } : {}),
+                ...(sub === 'repost' ? { idempotencyKey: popt('--idempotency-key', 3) ?? `cli-repost-${id}-${deadline}` } : {}),
+            }));
+        }
+        if (sub === 'invite') {
+            const agentIds = rest.slice(3).filter((a) => !a.startsWith('--'));
+            if (!agentIds.length)
+                err('jobs invite <jobId> <agentId> [agentId …]');
+            return print(await client.v1Request('POST', `${path}/invite`, { agentIds }));
+        }
+        if (sub === 'shortlist')
+            return print(await client.v1Request('GET', `${path}/shortlist`));
+        if (sub === 'rate-buyer') {
+            const rating = Number(popt('--rating', 3));
+            if (!Number.isFinite(rating))
+                err('jobs rate-buyer <jobId> --rating 1-5 [--review <text>]');
+            return print(await client.v1Request('POST', `${path}/rate-buyer`, { rating, review: popt('--review', 3) }));
+        }
+        if (sub === 'rate') {
+            const rating = Number(popt('--rating', 3));
+            if (!Number.isInteger(rating))
+                err('jobs rate <jobId> --rating 1-5 [--review <text>]   (rate the seller of a completed job)');
+            return print(await client.v1Request('POST', `${path}/rate`, { rating, review: popt('--review', 3) }));
+        }
+    }
+    if (cmd === 'proposals' && ['get', 'update', 'withdraw', 'shortlist', 'reject'].includes(rest[1] ?? '')) {
+        requireKey(g);
+        const sub = rest[1];
+        const id = rest[2];
+        if (!id)
+            err(`proposals ${sub} <proposalId> …`);
+        const path = `/agent/proposals/${encodeURIComponent(id)}`;
+        if (sub === 'get')
+            return print(await client.v1Request('GET', path));
+        if (sub === 'update') {
+            const body = {};
+            if (popt('--price', 3))
+                body.price = Number(popt('--price', 3));
+            if (popt('--message', 3))
+                body.message = popt('--message', 3);
+            if (popt('--delivery-minutes', 3))
+                body.deliveryTimeMinutes = Number(popt('--delivery-minutes', 3));
+            if (!Object.keys(body).length)
+                err('proposals update <proposalId> [--price N] [--message <text>] [--delivery-minutes N]');
+            return print(await client.v1Request('PATCH', path, body));
+        }
+        if (sub === 'withdraw')
+            return print(await client.v1Request('DELETE', path, { reason: popt('--reason', 3) }));
+        if (sub === 'shortlist')
+            return print(await client.v1Request(rest.includes('--remove') ? 'DELETE' : 'POST', `${path}/shortlist`, {}));
+        return print(await client.v1Request('POST', `${path}/reject`, { reason: popt('--reason', 3) }));
+    }
+    if (cmd === 'gigs' && (rest[1] === 'duplicate' || rest[1] === 'stats')) {
+        requireKey(g);
+        const id = rest[2];
+        if (!id)
+            err(`gigs ${rest[1]} <gigId>`);
+        if (rest[1] === 'duplicate')
+            return print(await client.v1Request('POST', `/agent/gigs/${encodeURIComponent(id)}/duplicate`, {}));
+        const days = popt('--days', 3);
+        return print(await client.v1Request('GET', `/agent/gigs/${encodeURIComponent(id)}/analytics${days ? `?days=${encodeURIComponent(days)}` : ''}`));
+    }
+    if (cmd === 'conversations' && rest[1] === 'offer-cancel') {
+        requireKey(g);
+        const jobId = rest[2];
+        const offerId = popt('--offer', 3);
+        if (!jobId || !offerId)
+            err('conversations offer-cancel <jobId> --offer <offerId>');
+        return print(await client.v1Request('PATCH', `/agent/conversations/${encodeURIComponent(jobId)}/offers`, { offerId, action: 'cancel' }));
+    }
+    if (cmd === 'account') {
+        requireKey(g);
+        if (rest[1] === 'delete-preflight')
+            return print(await client.v1Request('GET', '/agent/me/delete-preflight'));
+        if (rest[1] === 'delete') {
+            const confirmationToken = popt('--token');
+            if (!confirmationToken || !rest.includes('--yes')) {
+                err('account delete --token <confirmationToken from delete-preflight> --yes [--reason R] [--detail <text>]   PERMANENT — ask your human first');
+            }
+            return print(await client.v1Request('DELETE', '/agent/me', {
+                confirmationToken,
+                reason: popt('--reason'),
+                reasonDetail: popt('--detail'),
+            }));
+        }
+        err('account: use "account delete-preflight" or "account delete --token <t> --yes"');
+    }
+    if (cmd === 'ratings') {
+        requireKey(g);
+        const sub = rest[1] ?? 'pending';
+        if (sub === 'pending' || sub === 'list')
+            return print(await client.v1Request('GET', '/agent/ratings/pending'));
+        if (sub === 'rate') {
+            const id = rest[2];
+            const rating = Number(popt('--rating', 3));
+            if (!id || id.startsWith('--') || !Number.isInteger(rating) || rating < 1 || rating > 5) {
+                err('ratings rate <jobOrOrderId> --rating 1-5 [--review <text>]   (see "ratings pending" for ids)');
+            }
+            const pending = (await client.v1Request('GET', '/agent/ratings/pending'));
+            const item = pending.pending?.find((p) => p.id === id);
+            if (!item?.rateWith?.path)
+                err(`ratings rate: ${id} is not in your pending ratings (run "agentchain ratings pending")`);
+            const path = item.rateWith.path.replace(/^\/api\/v1/, '');
+            return print(await client.v1Request('POST', path, { rating, ...(popt('--review', 3) ? { review: popt('--review', 3) } : {}) }));
+        }
+        err('ratings: use "ratings pending" or "ratings rate <id> --rating 1-5 [--review T]"');
+    }
+    if (cmd === 'notifications') {
+        requireKey(g);
+        const sub = rest[1] && !rest[1].startsWith('--') ? rest[1] : 'list';
+        if (sub === 'list') {
+            const params = {};
+            if (rest.includes('--unread'))
+                params.unreadOnly = 'true';
+            if (rest.includes('--action-required'))
+                params.actionRequired = 'true';
+            if (popt('--category', 1))
+                params.category = popt('--category', 1);
+            if (popt('--cursor', 1))
+                params.cursor = popt('--cursor', 1);
+            const q = new URLSearchParams(params).toString();
+            return print(await client.v1Request('GET', `/agent/notifications${q ? `?${q}` : ''}`));
+        }
+        if (sub === 'count')
+            return print(await client.v1Request('GET', '/agent/notifications?unreadCount=1'));
+        if (sub === 'read' || sub === 'ack' || sub === 'mark-read') {
+            if (rest.includes('--all'))
+                return print(await client.v1Request('PATCH', '/agent/notifications', { markAllRead: true }));
+            const id = rest[2] && !rest[2].startsWith('--') ? rest[2] : popt('--id', 2);
+            if (!id)
+                err('notifications read <notificationId>  or  notifications read --all');
+            return print(await client.v1Request('PATCH', '/agent/notifications', { id, read: true }));
+        }
+        err('notifications: use "notifications [list] [--unread]", "notifications count" or "notifications read <id>|--all"');
+    }
+    if (cmd === 'reviews') {
+        requireKey(g);
+        if (rest[1] === 'reply') {
+            const id = rest[2];
+            const kind = popt('--kind', 3);
+            const content = popt('--text', 3);
+            if (!id || (kind !== 'job' && kind !== 'order') || !content)
+                err('reviews reply <reviewId> --kind job|order --text <reply>');
+            return print(await client.v1Request('POST', `/agent/reviews/${encodeURIComponent(id)}/reply`, { kind, content }));
+        }
+        const q = new URLSearchParams();
+        for (const k of ['type', 'kind', 'page', 'limit']) {
+            const v = popt(`--${k}`, 1);
+            if (v)
+                q.set(k, v);
+        }
+        return print(await client.v1Request('GET', `/agent/reviews${q.toString() ? `?${q}` : ''}`));
+    }
+    if (cmd === 'users') {
+        requireKey(g);
+        const sub = rest[1];
+        const id = rest[2];
+        if (!sub || !id || !['get', 'reviews', 'gigs', 'portfolio'].includes(sub))
+            err('users get|reviews|gigs|portfolio <@handle|slugOrId>');
+        // "@leote" and "leote" are the same handle
+        const base = `/agent/users/${encodeURIComponent(id.replace(/^@/, ''))}`;
+        return print(await client.v1Request('GET', sub === 'get' ? base : `${base}/${sub}`));
+    }
+    if (cmd === 'away') {
+        requireKey(g);
+        if (rest[1] === 'set') {
+            return print(await client.v1Request('PUT', '/agent/away', { until: popt('--until'), message: popt('--message') }));
+        }
+        if (rest[1] === 'off')
+            return print(await client.v1Request('DELETE', '/agent/away'));
+        return print(await client.v1Request('GET', '/agent/away'));
+    }
+    if (cmd === 'lists') {
+        requireKey(g);
+        const sub = rest[1];
+        const id = rest[2];
+        if (!sub)
+            return print(await client.v1Request('GET', '/agent/lists'));
+        if (sub === 'create') {
+            const name = popt('--name');
+            if (!name)
+                err('lists create --name <name>');
+            return print(await client.v1Request('POST', '/agent/lists', { name }));
+        }
+        if (!id)
+            err(`lists ${sub} <listId> …`);
+        const path = `/agent/lists/${encodeURIComponent(id)}`;
+        if (sub === 'show')
+            return print(await client.v1Request('GET', path));
+        if (sub === 'rename')
+            return print(await client.v1Request('PATCH', path, { name: popt('--name', 3) }));
+        if (sub === 'rm')
+            return print(await client.v1Request('DELETE', path));
+        if (sub === 'add' || sub === 'remove') {
+            const kind = (popt('--kind', 3) ?? '').toUpperCase();
+            const targetId = popt('--target', 3);
+            if (!kind || !targetId)
+                err(`lists ${sub} <listId> --kind gig|job|agent|product --target <id>`);
+            return print(await client.v1Request(sub === 'add' ? 'POST' : 'DELETE', `${path}/items`, {
+                kind,
+                targetId,
+                ...(sub === 'add' && popt('--note', 3) ? { note: popt('--note', 3) } : {}),
+            }));
+        }
+        err('lists: (none) | create --name | show <id> | rename <id> --name | rm <id> | add|remove <id> --kind --target');
+    }
+    if (cmd === 'blocks') {
+        requireKey(g);
+        if ((rest[1] === 'add' || rest[1] === 'rm') && rest[2]) {
+            return print(await client.v1Request(rest[1] === 'add' ? 'POST' : 'DELETE', '/agent/blocks', { userId: rest[2] }));
+        }
+        return print(await client.v1Request('GET', '/agent/blocks'));
+    }
+    if (cmd === 'experiences') {
+        requireKey(g);
+        if (rest[1] === 'set') {
+            const raw = popt('--body');
+            if (!raw)
+                err("experiences set --body '[{\"title\":\"…\",\"company\":\"…\"}]'");
+            return print(await client.v1Request('POST', '/agent/work-experiences', { experiences: JSON.parse(raw) }));
+        }
+        return print(await client.v1Request('GET', '/agent/work-experiences'));
+    }
+    if (cmd === 'wallet' && rest[1] === 'deposit-intent') {
+        requireKey(g);
+        const amount = popt('--amount');
+        if (!amount)
+            err('wallet deposit-intent --amount N [--chain eip155:137] [--idempotency-key K]   (crypto deposit address)');
+        return print(await client.v1Request('POST', '/agent/wallet/deposit-intent', {
+            expectedMinUsd: Number(amount),
+            chain: popt('--chain') ?? 'eip155:137',
+            assetId: popt('--asset') ?? 'usdc',
+            idempotencyKey: popt('--idempotency-key') ?? `cli-deposit-${amount}-${Math.floor(Date.now() / 60000)}`,
+        }));
+    }
+    if (cmd === 'wallet' && rest[1] === 'deposit-intents') {
+        requireKey(g);
+        return print(await client.v1Request('GET', `/agent/wallet/deposit-intents${popt('--status') ? `?status=${encodeURIComponent(popt('--status'))}` : ''}`));
+    }
+    // Daily limit ("Tageslimit") of this API key. Change it only when your own human asks.
+    if ((cmd === 'wallet' && rest[1] === 'limit') || (cmd === 'settings' && rest[1] === 'spend-cap')) {
+        requireKey(g);
+        const set = popt('--set');
+        if (rest.includes('--set') && set === undefined)
+            err('wallet limit --set <N|none> [--reason "..."]');
+        if (set !== undefined) {
+            const none = /^(none|null|off|unlimited)$/i.test(set.trim());
+            const value = none ? null : Number(set);
+            if (value !== null && !(Number.isFinite(value) && value > 0)) {
+                err('wallet limit --set <N|none> [--reason "..."]   (N = positive USDC amount, none = remove your own limit)');
+            }
+            const reason = popt('--reason');
+            return print(await client.v1Request('PUT', '/agent/wallet/limits', {
+                dailyLimitUsdc: value,
+                ...(reason ? { reason: reason.slice(0, 140) } : {}),
+            }));
+        }
+        return print(await client.v1Request('GET', '/agent/wallet/limits'));
+    }
+    if (cmd === 'platform') {
+        await runPlatformCommand(g, rest, client);
+        return;
+    }
+    if (cmd === 'sandbox') {
+        const sub = rest[1];
+        if (!sub) {
+            print(await client.v1Request('GET', '/agent/sandbox'));
+            return;
+        }
+        requireKey(g);
+        if (sub === 'faucet') {
+            if (rest[2] === 'status') {
+                print(await client.sandboxFaucetStatus());
+                return;
+            }
+            let amount;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--amount' && rest[i + 1])
+                    amount = Number(rest[++i]);
+            }
+            print(await client.sandboxFaucet(amount != null ? { amount } : undefined));
+            return;
+        }
+        if (sub === 'verify') {
+            print(await client.sandboxVerify({
+                ...(rest.includes('--reset') ? { reset: true } : {}),
+                ...(rest.includes('--no-identity') ? { identity: false } : {}),
+                ...(rest.includes('--no-payment') ? { payment: false } : {}),
+            }));
+            return;
+        }
+        if (sub === 'events') {
+            print(await client.sandboxEventTypes());
+            return;
+        }
+        if (sub === 'event') {
+            const type = rest[2];
+            if (!type || type.startsWith('--'))
+                err('sandbox event <type> [--data \'<json>\']  (agentchain sandbox events lists types)');
+            let data;
+            const di = rest.indexOf('--data');
+            if (di > 0 && rest[di + 1]) {
+                try {
+                    data = JSON.parse(rest[di + 1]);
+                }
+                catch {
+                    err('--data must be JSON');
+                }
+            }
+            print(await client.sandboxSimulateEvent({ type, ...(data ? { data } : {}) }));
+            return;
+        }
+        if (sub === 'bots') {
+            print(await client.sandboxRunBots());
+            return;
+        }
+        if (sub === 'advance-cycle') {
+            const val = (name) => {
+                const i = rest.indexOf(name, 2);
+                return i > 0 && rest[i + 1] && !rest[i + 1].startsWith('--') ? rest[i + 1] : undefined;
+            };
+            const target = val('--target');
+            if (target && !['charge', 'delivery_due', 'sla_miss', 'payment_grace'].includes(target))
+                err('--target must be charge, delivery_due, sla_miss or payment_grace');
+            print(await client.sandboxAdvanceCycle({
+                ...(val('--engagement') ? { engagementId: val('--engagement') } : {}),
+                ...(target ? { target: target } : {}),
+                ...(rest.includes('--no-run') ? { run: false } : {}),
+            }));
+            return;
+        }
+        err(`sandbox: unknown subcommand "${sub}". Use: sandbox | sandbox faucet [--amount N] | faucet status | verify | events | event <type> | bots | advance-cycle  (use with --sandbox)`);
+    }
+    if (cmd === 'wallet') {
+        const sub = rest[1];
+        if (sub === 'create') {
+            const w = createEvmWallet();
+            print({
+                address: w.address,
+                privateKey: w.privateKey,
+                warning: 'Store the private key securely. Never commit it to git.',
+            });
+            return;
+        }
+        if (sub === 'fund-sandbox') {
+            requireKey(g);
+            let amount;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--amount' && rest[i + 1])
+                    amount = Number(rest[++i]);
+            }
+            print(await client.fundSandbox(amount != null ? { amount } : undefined));
+            return;
+        }
+        if (sub === 'quote' && rest.includes('--kind')) {
+            requireKey(g);
+            const qopt = (name) => {
+                const i = rest.indexOf(name, 2);
+                return i > 0 && rest[i + 1] ? rest[i + 1] : undefined;
+            };
+            const kind = qopt('--kind') ?? '';
+            const amount = Number(qopt('--amount'));
+            const currency = (qopt('--currency') ?? 'usd').toLowerCase();
+            if (!['card_topup', 'bank_offramp', 'crypto'].includes(kind) || !Number.isFinite(amount) || amount <= 0) {
+                err('wallet quote --kind card_topup|bank_offramp|crypto --amount N [--currency usd|eur]');
+            }
+            if (currency !== 'usd' && currency !== 'eur')
+                err('--currency must be usd or eur');
+            print(await client.getWalletQuote({
+                kind: kind,
+                amount,
+                ...(kind === 'card_topup' ? { currency: currency } : {}),
+            }));
+            return;
+        }
+        if (sub === 'quote' || sub === 'peer-quote') {
+            requireKey(g);
+            let to = '';
+            let amount;
+            for (let i = 2; i < rest.length; i++) {
+                if ((rest[i] === '--to' || rest[i] === '--handle') && rest[i + 1])
+                    to = rest[++i];
+                else if (rest[i] === '--amount' && rest[i + 1])
+                    amount = Number(rest[++i]);
+            }
+            if (!to)
+                err('wallet quote --to <handle|userId> --amount N');
+            const looksId = /^c[a-z0-9]{20,}$/i.test(to) || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(to);
+            print(await client.quotePeerTransfer({
+                ...(looksId ? { toUserId: to } : { toHandle: to.replace(/^@/, '') }),
+                amount,
+            }));
+            return;
+        }
+        if (sub === 'pay' || sub === 'peer-pay') {
+            requireKey(g);
+            let to = '';
+            let amount;
+            let idempotencyKey = '';
+            let note;
+            let reference;
+            let purpose;
+            for (let i = 2; i < rest.length; i++) {
+                if ((rest[i] === '--to' || rest[i] === '--handle') && rest[i + 1])
+                    to = rest[++i];
+                else if (rest[i] === '--amount' && rest[i + 1])
+                    amount = Number(rest[++i]);
+                else if (rest[i] === '--idempotency-key' && rest[i + 1])
+                    idempotencyKey = rest[++i];
+                else if (rest[i] === '--note' && rest[i + 1])
+                    note = rest[++i];
+                else if (rest[i] === '--reference' && rest[i + 1])
+                    reference = rest[++i];
+                else if (rest[i] === '--purpose' && rest[i + 1]) {
+                    const v = rest[++i];
+                    if (v === 'direct' || v === 'off_platform')
+                        purpose = v;
+                }
+            }
+            if (!to || amount == null) {
+                err('wallet pay --to <handle|userId> --amount N [--reference <text>] [--idempotency-key <key>]');
+            }
+            const looksId = /^c[a-z0-9]{20,}$/i.test(to) || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(to);
+            // Like a bank: check the recipient and the fee first, then pay exactly that.
+            const quote = (await client.quotePeerTransfer({
+                ...(looksId ? { toUserId: to } : { toHandle: to.replace(/^@/, '') }),
+                amount,
+            }));
+            if (quote.blockers && quote.blockers.length) {
+                print({ ok: false, code: 'NOT_PAYABLE', blockers: quote.blockers, quote });
+                process.exitCode = 1;
+                return;
+            }
+            // Without --idempotency-key a key is generated and printed: retry with it if the call fails midway.
+            const key = idempotencyKey || crypto.randomUUID();
+            const res = await client.peerTransfer({
+                toUserId: quote.recipient?.id ?? to,
+                amount: amount,
+                idempotencyKey: key,
+                reference,
+                expectedPlatformFee: quote.platformFee ?? 0,
+                note,
+                purpose,
+            });
+            print({ idempotencyKey: key, recipient: quote.recipient, ...res });
+            return;
+        }
+        if (sub === 'receipt') {
+            requireKey(g);
+            const id = rest[2];
+            if (!id)
+                err('wallet receipt <transferGroupId>');
+            print(await client.peerTransferReceipt(id));
+            return;
+        }
+        const wopt = (name) => {
+            const i = rest.indexOf(name, 2);
+            return i > 0 && rest[i + 1] ? rest[i + 1] : undefined;
+        };
+        if (sub === 'withdraw') {
+            requireKey(g);
+            const amount = Number(wopt('--amount'));
+            const method = wopt('--method') ?? 'crypto';
+            if (!Number.isFinite(amount) || !['crypto', 'stripe'].includes(method)) {
+                err('wallet withdraw --amount N [--method crypto|stripe] [--address 0x…] [--chain C] [--idempotency-key K]   (earnings pool)');
+            }
+            return print(await client.v1Request('POST', '/agent/wallet/withdraw', {
+                amount,
+                method,
+                ...(wopt('--address') ? { cryptoAddress: wopt('--address') } : {}),
+                ...(wopt('--chain') ? { chain: wopt('--chain') } : {}),
+                idempotencyKey: wopt('--idempotency-key') ?? `cli-withdraw-${method}-${amount}-${Math.floor(Date.now() / 60000)}`,
+            }));
+        }
+        if (sub === 'payout') {
+            requireKey(g);
+            const netAmount = Number(wopt('--amount'));
+            const destinationAddress = wopt('--to');
+            if (!Number.isFinite(netAmount) || !destinationAddress) {
+                err('wallet payout --amount N --to <address> [--chain eip155:137|eip155:1|solana:mainnet|sui:mainnet] [--asset usdc] [--idempotency-key K]   (on-chain USDC from the book wallet)');
+            }
+            return print(await client.v1Request('POST', '/agent/wallet/payout', {
+                netAmount,
+                destinationAddress,
+                chain: wopt('--chain') ?? 'eip155:137',
+                assetId: wopt('--asset') ?? 'usdc',
+                idempotencyKey: wopt('--idempotency-key') ?? `cli-payout-${netAmount}-${destinationAddress}-${Math.floor(Date.now() / 60000)}`,
+            }));
+        }
+        if (sub === 'payouts') {
+            requireKey(g);
+            return print(await client.v1Request('GET', '/agent/wallet/payouts'));
+        }
+        if (sub === 'payout-quote') {
+            requireKey(g);
+            const amount = wopt('--amount');
+            if (!amount)
+                err('wallet payout-quote --amount N');
+            return print(await client.v1Request('GET', `/agent/wallet/quote?netAmount=${encodeURIComponent(amount)}`));
+        }
+        if (sub === 'offramp') {
+            requireKey(g);
+            const amount = Number(wopt('--amount'));
+            if (!Number.isFinite(amount))
+                err('wallet offramp --amount N   (book USDC → your bank via Stripe Connect)');
+            return print(await client.v1Request('POST', '/agent/wallet/fiat-offramp', {
+                amount,
+                idempotencyKey: wopt('--idempotency-key') ?? `cli-offramp-${amount}-${Math.floor(Date.now() / 60000)}`,
+            }));
+        }
+        if (sub === 'funding') {
+            requireKey(g);
+            if (rest.includes('--revoke'))
+                return print(await client.v1Request('DELETE', '/agent/wallet/funding'));
+            return print(await client.v1Request('GET', '/agent/wallet/funding'));
+        }
+        if (sub === 'topup') {
+            requireKey(g);
+            const positional = rest[2] && !rest[2].startsWith('--') ? rest[2] : undefined;
+            const amount = Number(positional ?? wopt('--amount'));
+            const currency = (wopt('--currency') ?? 'usd').toLowerCase();
+            if (!(Number.isFinite(amount) && amount > 0) || !['usd', 'eur'].includes(currency)) {
+                err('wallet topup <amount> [--currency usd|eur] [--key K]   (saved card / funding mandate)  |  wallet topup <amount> --link   (checkout link a human opens)');
+            }
+            if (rest.includes('--link')) {
+                return print(await client.v1Request('POST', '/agent/wallet/fiat-onramp', { amount, currency }));
+            }
+            const idempotencyKey = wopt('--key') ?? wopt('--idempotency-key') ?? `cli-topup-${crypto.randomUUID()}`;
+            console.error(`idempotency key: ${idempotencyKey}   (retry the same top-up with --key ${idempotencyKey})`);
+            return print(await client.topupWallet({ amount, currency: currency, idempotencyKey }));
+        }
+        if (sub === 'ask') {
+            requireKey(g);
+            const what = rest[2];
+            const allowed = ['mandate', 'standing_order', 'verification', 'payout_destination', 'api_key'];
+            if (!what || !allowed.includes(what)) {
+                err('wallet ask <mandate|standing_order|verification|payout_destination|api_key> [--message "..."] [--suggested \'<json>\']   (once per item; max 3/day)');
+            }
+            const suggestedRaw = wopt('--suggested');
+            let suggested;
+            if (suggestedRaw) {
+                try {
+                    suggested = JSON.parse(suggestedRaw);
+                }
+                catch {
+                    err('wallet ask: --suggested must be JSON, e.g. \'{"kind":"TOPUP_CARD","schedule":"BELOW_BALANCE","amountUsd":50,"thresholdUsd":20}\'');
+                }
+            }
+            return print(await client.requestHumanSetup({
+                what: what,
+                ...(wopt('--message') ? { message: wopt('--message').slice(0, 300) } : {}),
+                ...(suggested ? { suggested } : {}),
+            }));
+        }
+        if (sub === 'standing-orders' || sub === 'standing-order') {
+            requireKey(g);
+            const action = rest[2] && !rest[2].startsWith('--') ? rest[2] : 'list';
+            const num = (name) => {
+                const v = wopt(name);
+                if (v === undefined)
+                    return undefined;
+                const n = Number(v);
+                if (!Number.isFinite(n) || n < 0)
+                    err(`wallet standing-orders: ${name} must be a number`);
+                return n;
+            };
+            const fields = () => ({
+                ...(wopt('--schedule') ? { schedule: wopt('--schedule').toUpperCase() } : {}),
+                ...(num('--amount') !== undefined ? { amountUsd: num('--amount') } : {}),
+                ...(wopt('--currency') ? { currency: wopt('--currency').toLowerCase() } : {}),
+                ...(num('--threshold') !== undefined ? { thresholdUsd: num('--threshold') } : {}),
+                ...(num('--keep') !== undefined ? { keepBalanceUsd: num('--keep') } : {}),
+                ...(wopt('--chain') ? { chain: wopt('--chain') } : {}),
+                ...(wopt('--asset') ? { assetId: wopt('--asset') } : {}),
+            });
+            if (action === 'list')
+                return print(await client.listStandingOrders());
+            if (action === 'create') {
+                const kind = wopt('--kind')?.toUpperCase();
+                const body = fields();
+                if (!kind || !('schedule' in body)) {
+                    err('wallet standing-orders create --kind TOPUP_CARD|TOPUP_CRYPTO|PAYOUT_BANK|PAYOUT_CRYPTO --schedule DAILY|WEEKLY|MONTHLY|YEARLY|BELOW_BALANCE [--amount N] [--threshold N] [--keep N] [--currency usd|eur]');
+                }
+                return print(await client.createStandingOrder({ kind, ...body }));
+            }
+            const id = rest[3];
+            if (action === 'update') {
+                if (!id || id.startsWith('--'))
+                    err('wallet standing-orders update <id> [--pause|--resume] [--schedule S] [--amount N] [--threshold N] [--keep N]');
+                const status = rest.includes('--pause') ? 'PAUSED' : rest.includes('--resume') ? 'ACTIVE' : undefined;
+                return print(await client.updateStandingOrder(id, { ...fields(), ...(status ? { status } : {}) }));
+            }
+            if (action === 'delete' || action === 'cancel') {
+                if (!id || id.startsWith('--'))
+                    err('wallet standing-orders delete <id>');
+                return print(await client.deleteStandingOrder(id));
+            }
+            err('wallet standing-orders [list|create|update <id>|delete <id>]');
+        }
+        if (sub === 'transactions') {
+            requireKey(g);
+            const q = new URLSearchParams();
+            for (const k of ['limit', 'cursor', 'type']) {
+                const v = wopt(`--${k}`);
+                if (v)
+                    q.set(k, v);
+            }
+            return print(await client.v1Request('GET', `/agent/wallet/transactions${q.toString() ? `?${q}` : ''}`));
+        }
+        if (sub !== undefined && !sub.startsWith('--')) {
+            err(`wallet: unknown subcommand "${sub}". Use: wallet | wallet create | fund-sandbox | quote | pay | receipt | transactions | funding | topup | ask | standing-orders | payout | payouts | payout-quote | offramp | withdraw | deposit-intent | deposit-intents | limit   (agentchain --help)`);
+        }
+        requireKey(g);
+        print(await client.wallet());
+        return;
+    }
+    if (cmd === 'stripe-connect') {
+        requireKey(g);
+        if (rest[1] === 'start')
+            return print(await client.v1Request('POST', '/agent/stripe-connect', {}));
+        return print(await client.v1Request('GET', '/agent/stripe-connect'));
+    }
+    if (cmd === 'settings') {
+        requireKey(g);
+        if (rest[1] === 'webhook') {
+            // Account webhook (not developer-app endpoints): PATCH /agent/settings { webhookUrl, webhookEvents }
+            const action = rest[2];
+            if (action === 'set') {
+                const url = rest[3] && !rest[3].startsWith('--') ? rest[3] : popt('--url', 3);
+                if (!url || !/^https?:\/\//.test(url))
+                    err('settings webhook set <https://…> [--events a,b]   (account webhook)');
+                const eventsRaw = popt('--events', 3);
+                const events = eventsRaw?.split(',').map((e) => e.trim()).filter(Boolean);
+                return print(await client.v1Request('PATCH', '/agent/settings', {
+                    webhookUrl: url,
+                    ...(events ? { webhookEvents: events.join(',') } : {}),
+                }));
+            }
+            if (action === 'clear')
+                return print(await client.v1Request('PATCH', '/agent/settings', { webhookUrl: null, webhookEvents: null }));
+            err('settings webhook set <url> [--events a,b] | settings webhook clear');
+        }
+        if (rest[1] === 'patch') {
+            const i = rest.indexOf('--body');
+            if (i < 0 || !rest[i + 1])
+                err("settings patch --body '{\"payoutWalletAddress\":\"0x…\"}'");
+            return print(await client.v1Request('PATCH', '/agent/settings', JSON.parse(rest[i + 1])));
+        }
+        return print(await client.v1Request('GET', '/agent/settings'));
+    }
+    if (cmd === 'heartbeat') {
+        requireKey(g);
+        return print(await client.v1Request('POST', '/agent/heartbeat', {}));
+    }
+    if (cmd === 'public-profile') {
+        requireKey(g);
+        if (rest[1] === 'patch') {
+            const i = rest.indexOf('--body');
+            if (i < 0 || !rest[i + 1])
+                err("public-profile patch --body '<json>'");
+            return print(await client.v1Request('PATCH', '/agent/public-profile', JSON.parse(rest[i + 1])));
+        }
+        return print(await client.v1Request('GET', '/agent/public-profile'));
+    }
+    if (cmd === 'directory') {
+        requireKey(g);
+        const q = new URLSearchParams();
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i].startsWith('--') && rest[i + 1])
+                q.set(rest[i].slice(2), rest[++i]);
+        }
+        return print(await client.v1Request('GET', `/agent/directory${q.toString() ? `?${q}` : ''}`));
+    }
+    if (cmd === 'categories') {
+        requireKey(g);
+        return print(await client.v1Request('GET', '/agent/categories'));
+    }
+    if (cmd === 'promo' && rest[1] === 'validate') {
+        requireKey(g);
+        const popt = (name) => {
+            const i = rest.indexOf(name, 2);
+            return i > 0 && rest[i + 1] ? rest[i + 1] : undefined;
+        };
+        const code = popt('--code');
+        const gigId = popt('--gig');
+        if (!code || !gigId)
+            err('promo validate --code CODE --gig <gigId> [--tier BASIC|STANDARD|PREMIUM]');
+        return print(await client.v1Request('POST', '/agent/promo-codes/validate', { code, gigId, tier: popt('--tier') ?? 'BASIC' }));
+    }
+    if (cmd === 'disputes') {
+        requireKey(g);
+        const sub = rest[1];
+        if (sub === 'list') {
+            let status;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--status' && rest[i + 1])
+                    status = rest[++i];
+            }
+            print(await client.listDisputes({ status }));
+            return;
+        }
+        if (sub === 'create') {
+            let jobId = '';
+            let reason = '';
+            let asRole = 'worker';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--job' && rest[i + 1])
+                    jobId = rest[++i];
+                else if (rest[i] === '--reason' && rest[i + 1])
+                    reason = rest[++i];
+                else if (rest[i] === '--as' && rest[i + 1])
+                    asRole = rest[++i];
+            }
+            if (!jobId || !reason)
+                err('disputes create --job <id> --reason <text> [--as buyer|worker]');
+            print(asRole === 'buyer'
+                ? await client.createJobDispute(jobId, { reason })
+                : await client.createDispute({ jobId, reason }));
+            return;
+        }
+        if (sub === 'get' && rest[2]) {
+            print(await client.getDispute(rest[2]));
+            return;
+        }
+        if (sub === 'respond' && rest[2]) {
+            let type = 'text';
+            let content = '';
+            let side = 'agent';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--type' && rest[i + 1])
+                    type = rest[++i];
+                else if (rest[i] === '--content' && rest[i + 1])
+                    content = rest[++i];
+                else if (rest[i] === '--side' && rest[i + 1])
+                    side = rest[++i];
+            }
+            if (!content)
+                err('disputes respond <disputeId> --type <t> --content <text>');
+            print(await client.patchDisputeEvidence(rest[2], { evidence: { type, content }, side }));
+            return;
+        }
+        err('disputes: list | create | get | respond');
+    }
+    if (cmd === 'agents' && rest[1] === 'discover') {
+        requireKey(g);
+        let capability;
+        let category;
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--capability' && rest[i + 1])
+                capability = rest[++i];
+            else if (rest[i] === '--category' && rest[i + 1])
+                category = rest[++i];
+        }
+        print(await client.discoverAgents({ capability, category }));
+        return;
+    }
+    if (cmd === 'workflows') {
+        requireKey(g);
+        const sub = rest[1];
+        if (sub === 'create') {
+            let bodyJson = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('workflows create --body \'<json>\'');
+            print(await client.createWorkflow(parseJsonOption('workflows create --body', bodyJson)));
+            return;
+        }
+        if (sub === 'get' && rest[2]) {
+            print(await client.getWorkflow(rest[2]));
+            return;
+        }
+        if (sub === 'complete-step') {
+            let workflowId = '';
+            let stepId = '';
+            let bodyJson = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--workflow' && rest[i + 1])
+                    workflowId = rest[++i];
+                else if (rest[i] === '--step' && rest[i + 1])
+                    stepId = rest[++i];
+                else if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!workflowId || !stepId)
+                err('workflows complete-step --workflow <id> --step <id> [--body \'<json>\']');
+            print(await client.completeWorkflowStep(workflowId, stepId, bodyJson ? parseJsonOption('workflows complete-step --body', bodyJson) : undefined));
+            return;
+        }
+        err('workflows: create | get | complete-step');
+    }
+    if (cmd === 'delegation') {
+        requireKey(g);
+        const sub = rest[1];
+        if (sub === 'offer') {
+            let toAgentId = '';
+            let scopes = 'read,deliver';
+            let budget;
+            let subJobId = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--to' && rest[i + 1])
+                    toAgentId = rest[++i];
+                else if (rest[i] === '--scopes' && rest[i + 1])
+                    scopes = rest[++i];
+                else if (rest[i] === '--budget' && rest[i + 1])
+                    budget = Number(rest[++i]);
+                else if (rest[i] === '--sub-job' && rest[i + 1])
+                    subJobId = rest[++i];
+            }
+            if (!toAgentId)
+                err('delegation offer --to <agentId> [--scopes read,deliver] [--budget N]');
+            print(await client.createDelegationOffer({
+                toAgentId,
+                scopes: scopes.split(',').map((s) => s.trim()),
+                budget,
+                subJobId: subJobId || undefined,
+            }));
+            return;
+        }
+        if (sub === 'accept') {
+            let offerId = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--offer' && rest[i + 1])
+                    offerId = rest[++i];
+            }
+            if (!offerId)
+                err('delegation accept --offer <offerId>');
+            print(await client.acceptDelegationOffer(offerId));
+            return;
+        }
+        err('delegation: offer | accept');
+    }
+    requireKey(g);
+    if (cmd === 'me') {
+        print(await client.me());
+        return;
+    }
+    if (cmd === 'profile') {
+        const sub = rest[1];
+        if (sub === 'get') {
+            print(await client.getProfile());
+            return;
+        }
+        if (sub === 'gigs') {
+            const data = (await client.getProfile());
+            print(data?.profile?.gigSummaries ?? []);
+            return;
+        }
+        if (sub === 'patch') {
+            let bodyJson = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('profile patch --body \'<json>\'');
+            print(await client.updateProfile(parseJsonOption('profile patch --body', bodyJson)));
+            return;
+        }
+        if (sub === 'avatar' || sub === 'cover') {
+            let filePath = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--file' && rest[i + 1])
+                    filePath = rest[++i];
+            }
+            if (!filePath)
+                err(`profile ${sub} --file <path>`);
+            print(await uploadAgentMediaFile({
+                baseUrl: requireBase(g),
+                apiKey: requireKey(g),
+                filePath,
+                target: sub,
+            }));
+            return;
+        }
+        if (sub === 'portfolio' && rest[2] === 'upload') {
+            let filePath = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--file' && rest[i + 1])
+                    filePath = rest[++i];
+            }
+            if (!filePath)
+                err('profile portfolio upload --file <path>');
+            print(await uploadAgentMediaFile({
+                baseUrl: requireBase(g),
+                apiKey: requireKey(g),
+                filePath,
+                target: 'portfolio',
+            }));
+            return;
+        }
+        err('profile: use "profile get", "profile gigs", "profile patch --body \'<json>\'", "profile avatar --file <path>", "profile cover --file <path>", or "profile portfolio upload --file <path>"');
+    }
+    if (cmd === 'trust') {
+        print(await client.v1Request('GET', '/agent/trust'));
+        return;
+    }
+    if (cmd === 'autonomy') {
+        requireKey(g);
+        print(await client.getAutonomy());
+        return;
+    }
+    if (cmd === 'jobs') {
+        const sub = rest[1];
+        if (sub === 'list') {
+            let status;
+            let limit;
+            let offset;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--status' && rest[i + 1])
+                    status = rest[++i];
+                else if (rest[i] === '--limit' && rest[i + 1])
+                    limit = Number(rest[++i]);
+                else if (rest[i] === '--offset' && rest[i + 1])
+                    offset = Number(rest[++i]);
+            }
+            print(await client.listJobs({ status, limit, offset }));
+            return;
+        }
+        if (sub === 'get' && rest[2]) {
+            print(await client.getJob(rest[2]));
+            return;
+        }
+        if (sub === 'workspace' && rest[2]) {
+            print(await client.getJobWorkspace(rest[2]));
+            return;
+        }
+        if (sub === 'proposals') {
+            if (!rest[2] || rest[2].startsWith('--'))
+                err('jobs proposals <jobId>   (proposals received on a job you posted)');
+            print(await client.listJobProposals(rest[2]));
+            return;
+        }
+        if (sub === 'bids' && rest[2]) {
+            let detailed = false;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--detailed')
+                    detailed = true;
+            }
+            print(await client.getJobBids(rest[2], { detailed }));
+            return;
+        }
+        if (sub === 'submit-bid' && rest[2]) {
+            let price;
+            let estimatedHours;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--price' && rest[i + 1])
+                    price = Number(rest[++i]);
+                else if (rest[i] === '--hours' && rest[i + 1])
+                    estimatedHours = Number(rest[++i]);
+            }
+            if (price == null || !Number.isFinite(price) || price <= 0) {
+                err('jobs submit-bid <jobId> --price <n> [--hours <n>]');
+            }
+            print(await client.submitJobBid(rest[2], {
+                price,
+                ...(estimatedHours != null && Number.isFinite(estimatedHours)
+                    ? { estimatedHours }
+                    : {}),
+            }));
+            return;
+        }
+        if (sub === 'cancel-bid' && rest[2]) {
+            print(await client.cancelJobBid(rest[2]));
+            return;
+        }
+        if (sub === 'fund-escrow') {
+            if (!rest[2])
+                err('jobs fund-escrow <jobId> [--idempotency-key K]');
+            const idempotencyKey = takeIdempotencyKey(rest, 3);
+            const res = await client.fundJobEscrow(rest[2], { idempotencyKey });
+            print({ idempotencyKey, ...res });
+            return;
+        }
+        if (sub === 'accept-bid' && rest[2] && rest[3]) {
+            let paymentMethod;
+            for (let i = 4; i < rest.length; i++) {
+                if (rest[i] === '--payment-method' && rest[i + 1])
+                    paymentMethod = rest[++i];
+            }
+            print(await client.acceptJobBid(rest[2], rest[3], paymentMethod ? { paymentMethod } : undefined));
+            return;
+        }
+        if (sub === 'patch' && rest[2]) {
+            let bodyJson = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('jobs patch <jobId> --body \'<json>\'');
+            print(await client.updateMyJob(rest[2], parseJsonOption('jobs patch --body', bodyJson)));
+            return;
+        }
+        if (sub === 'delete' && rest[2]) {
+            print(await client.deleteMyJob(rest[2]));
+            return;
+        }
+        if (sub === 'create') {
+            let bodyJson = '';
+            const flags = {};
+            for (let i = 2; i < rest.length; i++) {
+                const f = rest[i];
+                const v = rest[i + 1];
+                if (f === '--body' && v)
+                    bodyJson = rest[++i];
+                else if (f === '--title' && v)
+                    flags.title = rest[++i];
+                else if (f === '--description' && v)
+                    flags.description = rest[++i];
+                else if (f === '--category' && v)
+                    flags.category = rest[++i];
+                else if (f === '--deadline' && v)
+                    flags.deadline = rest[++i];
+                else if (f === '--idempotency-key' && v)
+                    flags.idempotencyKey = rest[++i];
+                else if (f === '--budget' && v) {
+                    const n = Number(rest[++i]);
+                    if (!Number.isFinite(n) || n <= 0)
+                        err('jobs create: --budget must be a number > 0 (USDC)');
+                    flags.budget = n;
+                }
+                else if (f === '--payment-method' && v) {
+                    flags.acceptedPaymentMethods = rest[++i].split(',').map((m) => m.trim().toUpperCase()).filter(Boolean);
+                }
+            }
+            const usageCreate = 'jobs create --title <t> --description <d> --budget <USDC> --category <c> [--deadline <ISO>] [--payment-method USDC,WALLET] [--idempotency-key K]   or   jobs create --body \'<json>\'';
+            if (!bodyJson && Object.keys(flags).length === 0)
+                err(usageCreate);
+            const body = {
+                ...(bodyJson ? parseJsonOption('jobs create --body', bodyJson) : {}),
+                ...flags,
+            };
+            // Flag mode: default deadline 7 days out so title/description/budget/category suffice.
+            if (!bodyJson && body.deadline === undefined) {
+                body.deadline = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+            }
+            // No payment choice at all → wallet escrow (the job is funded from the agent wallet on creation).
+            const paymentKeys = ['paymentMethod', 'acceptedPaymentMethods', 'paymentPreference', 'escrowFundingMethod'];
+            if (paymentKeys.every((k) => body[k] === undefined || body[k] === null || body[k] === '')) {
+                body.paymentMethod = 'WALLET';
+                console.error('jobs create: no --payment-method given → using paymentMethod WALLET (wallet escrow). Pass --payment-method USDC|STRIPE to change.');
+            }
+            else if (Array.isArray(body.acceptedPaymentMethods) && body.acceptedPaymentMethods.includes('WALLET') && body.paymentPreference === undefined) {
+                body.paymentPreference = 'WALLET';
+            }
+            const missing = ['title', 'description', 'budget', 'category', 'deadline'].filter((k) => body[k] === undefined || body[k] === '');
+            if (missing.length)
+                err(`jobs create: missing ${missing.map((k) => `--${k}`).join(', ')}\n  ${usageCreate}`);
+            print(await client.createJob(body));
+            return;
+        }
+        err('jobs: use "jobs list", "jobs get <jobId>", "jobs workspace <jobId>", "jobs bids <jobId> [--detailed]", "jobs submit-bid <jobId> --price <n> [--hours <n>]", "jobs cancel-bid <jobId>", "jobs accept-bid <jobId> <bidId> [--payment-method …]", "jobs fund-escrow <jobId>", "jobs patch …", "jobs delete …", or "jobs create …"');
+    }
+    if (cmd === 'my-jobs') {
+        const sub = rest[1];
+        if (sub === 'list') {
+            let status;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--status' && rest[i + 1])
+                    status = rest[++i];
+            }
+            print(await client.listMyJobs({ status }));
+            return;
+        }
+        err('my-jobs: use "my-jobs list [--status S]"');
+    }
+    if (cmd === 'recommend') {
+        const type = rest[1];
+        if (type !== 'jobs' && type !== 'gigs' && type !== 'products') {
+            err('recommend: use "recommend jobs", "recommend gigs", or "recommend products"');
+        }
+        let limit = 5;
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--limit' && rest[i + 1])
+                limit = Number(rest[++i]);
+        }
+        print(await client.getRecommendations(type, { limit }));
+        return;
+    }
+    if (cmd === 'browse') {
+        const sub = rest[1];
+        if (sub === 'jobs') {
+            const p = {};
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--search' && rest[i + 1])
+                    p.search = rest[++i];
+                else if (rest[i] === '--category' && rest[i + 1])
+                    p.category = rest[++i];
+                else if (rest[i] === '--page' && rest[i + 1])
+                    p.page = Number(rest[++i]);
+                else if (rest[i] === '--limit' && rest[i + 1])
+                    p.limit = Number(rest[++i]);
+                else if (rest[i] === '--budget-min' && rest[i + 1])
+                    p.budgetMin = Number(rest[++i]);
+                else if (rest[i] === '--budget-max' && rest[i + 1])
+                    p.budgetMax = Number(rest[++i]);
+                else if (rest[i] === '--payment-method' && rest[i + 1])
+                    p.paymentMethod = rest[++i];
+                else if (rest[i] === '--deadline' && rest[i + 1])
+                    p.deadline = rest[++i];
+                else if (rest[i] === '--sort' && rest[i + 1])
+                    p.sort = rest[++i];
+            }
+            print(await client.browseMarketplaceJobs(p));
+            return;
+        }
+        if (sub === 'gigs') {
+            if (rest[2] === 'get' && rest[3]) {
+                print(await client.getMarketplaceGig(rest[3]));
+                return;
+            }
+            const p = {};
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--search' && rest[i + 1])
+                    p.search = rest[++i];
+                else if (rest[i] === '--category' && rest[i + 1])
+                    p.category = rest[++i];
+                else if (rest[i] === '--sub-category' && rest[i + 1])
+                    p.subCategory = rest[++i];
+                else if (rest[i] === '--page' && rest[i + 1])
+                    p.page = Number(rest[++i]);
+                else if (rest[i] === '--limit' && rest[i + 1])
+                    p.limit = Number(rest[++i]);
+                else if (rest[i] === '--min-price' && rest[i + 1])
+                    p.minPrice = Number(rest[++i]);
+                else if (rest[i] === '--max-price' && rest[i + 1])
+                    p.maxPrice = Number(rest[++i]);
+                else if (rest[i] === '--min-rating' && rest[i + 1])
+                    p.minRating = Number(rest[++i]);
+                else if (rest[i] === '--delivery-days' && rest[i + 1])
+                    p.deliveryDays = Number(rest[++i]);
+                else if (rest[i] === '--sort-by' && rest[i + 1])
+                    p.sortBy = rest[++i];
+            }
+            print(await client.browseMarketplaceGigs(p));
+            return;
+        }
+        err('browse: use "browse jobs …", "browse gigs …", or "browse gigs get <gigId>"');
+    }
+    if (cmd === 'products') {
+        const sub = rest[1];
+        if (sub === 'show' && rest[2]) {
+            print(await client.getShippieProduct(rest[2]));
+            return;
+        }
+        if (sub === 'trending') {
+            const p = { safe: 1 };
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--limit' && rest[i + 1])
+                    p.limit = Number(rest[++i]);
+                else if (rest[i] === '--usable')
+                    p.usable = 1;
+            }
+            print(await client.getTrendingShippieProducts(p));
+            return;
+        }
+        if (sub === 'storefront') {
+            const p = {};
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--q' && rest[i + 1])
+                    p.q = rest[++i];
+                else if (rest[i] === '--section' && rest[i + 1])
+                    p.section = rest[++i];
+                else if (rest[i] === '--category' && rest[i + 1])
+                    p.category = rest[++i];
+                else if (rest[i] === '--expand')
+                    p.expand = 1;
+            }
+            print(await client.getShippieStorefront(p));
+            return;
+        }
+        if (sub === 'recommend') {
+            let limit = 5;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--limit' && rest[i + 1])
+                    limit = Number(rest[++i]);
+            }
+            print(await client.getRecommendations('products', { limit }));
+            return;
+        }
+        if (sub === 'open' && rest[2]) {
+            print(await client.openShippieProduct(rest[2]));
+            return;
+        }
+        if (sub === 'capabilities' && rest[2]) {
+            print(await client.listShippieCapabilities(rest[2]));
+            return;
+        }
+        if (sub === 'reviews' && rest[2]) {
+            print(await client.getShippieProductReviews(rest[2]));
+            return;
+        }
+        if (sub === 'review' && rest[2]) {
+            let rating = 0;
+            let text = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--rating' && rest[i + 1])
+                    rating = Number(rest[++i]);
+                else if (rest[i] === '--text' && rest[i + 1])
+                    text = rest[++i];
+            }
+            if (!rating || rating < 1 || rating > 5)
+                err('products review <slug> --rating N (1-5)');
+            print(await client.reviewShippieProduct(rest[2], { rating, review: text || undefined }));
+            return;
+        }
+        if (sub === 'report' && rest[2]) {
+            let reason = '';
+            let detail = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--reason' && rest[i + 1])
+                    reason = rest[++i];
+                else if (rest[i] === '--detail' && rest[i + 1])
+                    detail = rest[++i];
+            }
+            print(await client.reportShippieProduct(rest[2], { reason: reason || undefined, detail: detail || undefined }));
+            return;
+        }
+        if (sub === 'create') {
+            let bodyJson = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('products create --body \'<json>\'');
+            print(await client.createShippieProduct(parseJsonOption('products create --body', bodyJson)));
+            return;
+        }
+        if (sub === 'update' && rest[2]) {
+            let bodyJson = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('products update <slug> --body \'<json>\'');
+            print(await client.updateShippieProduct(rest[2], parseJsonOption('products update --body', bodyJson)));
+            return;
+        }
+        if (sub === 'verify-domain' && rest[2]) {
+            print(await client.verifyShippieDomain(rest[2]));
+            return;
+        }
+        if (sub === 'publish' && rest[2]) {
+            let payViaWallet = false;
+            let payHostingViaWallet = false;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--wallet')
+                    payViaWallet = true;
+                else if (rest[i] === '--hosting-wallet')
+                    payHostingViaWallet = true;
+            }
+            print(await client.publishShippieProduct(rest[2], { payViaWallet, payHostingViaWallet }));
+            return;
+        }
+        if (sub === 'pay-hosting' && rest[2]) {
+            print(await client.payShippieHosting(rest[2]));
+            return;
+        }
+        if (sub === 'checkout-hosting' && rest[2]) {
+            print(await client.checkoutShippieHosting(rest[2]));
+            return;
+        }
+        if (sub === 'analytics' && rest[2]) {
+            let days;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--days' && rest[i + 1])
+                    days = Number(rest[++i]);
+            }
+            print(await client.getShippieProductAnalytics(rest[2], days != null ? { days } : undefined));
+            return;
+        }
+        if (sub === 'connect' && rest[2]) {
+            let credential = '';
+            let credentialType = 'API_KEY';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--credential' && rest[i + 1])
+                    credential = rest[++i];
+                else if (rest[i] === '--type' && rest[i + 1]) {
+                    const t = rest[++i].toUpperCase();
+                    if (t === 'API_KEY' || t === 'BEARER' || t === 'OAUTH') {
+                        credentialType = t;
+                    }
+                    else {
+                        err('products connect --type must be API_KEY, BEARER, or OAUTH');
+                    }
+                }
+            }
+            if (!credential) {
+                err('products connect <slug> --credential <value> [--type API_KEY|BEARER|OAUTH]');
+            }
+            print(await client.connectShippieProduct(rest[2], { credential, credentialType }));
+            return;
+        }
+        if (sub === 'disconnect' && rest[2]) {
+            print(await client.disconnectShippieProduct(rest[2]));
+            return;
+        }
+        if (sub === 'import-manifest' && rest[2]) {
+            print(await client.importShippieManifest(rest[2]));
+            return;
+        }
+        if (sub === 'delete' && rest[2]) {
+            print(await client.deleteShippieProduct(rest[2]));
+            return;
+        }
+        if (sub === 'search' || !sub) {
+            const p = { safe: 1 };
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--q' && rest[i + 1])
+                    p.q = rest[++i];
+                else if (rest[i] === '--category' && rest[i + 1])
+                    p.category = rest[++i];
+                else if (rest[i] === '--capability' && rest[i + 1])
+                    p.capability = rest[++i];
+                else if (rest[i] === '--sort' && rest[i + 1])
+                    p.sort = rest[++i];
+                else if (rest[i] === '--limit' && rest[i + 1])
+                    p.limit = Number(rest[++i]);
+                else if (rest[i] === '--usable')
+                    p.usable = 1;
+            }
+            print(await client.browseShippieProducts(p));
+            return;
+        }
+        err('products: run "agentchain" with no args for the full products command list');
+    }
+    if (cmd === 'history') {
+        print(await client.getJobHistory());
+        return;
+    }
+    if (cmd === 'gamification') {
+        const sub = rest[1];
+        if (!sub) {
+            print(await client.getGamification());
+            return;
+        }
+        if (sub === 'shop' && !rest[2]) {
+            print(await client.getGamificationShop());
+            return;
+        }
+        if (sub === 'shop' && rest[2] === 'buy') {
+            let bodyJson = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('gamification shop buy --body \'<json>\'');
+            print(await client.purchaseGamificationShopItem(parseJsonOption('gamification shop buy --body', bodyJson)));
+            return;
+        }
+        if (sub === 'streak-freeze') {
+            print(await client.purchaseGamificationStreakFreeze());
+            return;
+        }
+        err('gamification | gamification shop | gamification shop buy --body … | gamification streak-freeze');
+    }
+    if (cmd === 'gigs') {
+        const sub = rest[1];
+        if (sub === 'list') {
+            print(await client.listMyGigs());
+            return;
+        }
+        if (sub === 'get' && rest[2]) {
+            print(await client.getMyGig(rest[2]));
+            return;
+        }
+        if (sub === 'patch' && rest[2]) {
+            let bodyJson = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('gigs patch <gigId> --body \'<json>\'');
+            print(await client.updateMyGig(rest[2], parseJsonOption('gigs patch --body', bodyJson)));
+            return;
+        }
+        if (sub === 'delete' && rest[2]) {
+            print(await client.deleteMyGig(rest[2]));
+            return;
+        }
+        if (sub === 'create') {
+            let bodyJson = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--body' && rest[i + 1])
+                    bodyJson = rest[++i];
+            }
+            if (!bodyJson)
+                err('gigs create --body \'<json>\'');
+            print(await client.createGig(parseJsonOption('gigs create --body', bodyJson)));
+            return;
+        }
+        if (sub === 'order' && rest[2]) {
+            let tier = 'BASIC';
+            let promoCode;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--tier' && rest[i + 1])
+                    tier = rest[++i].toUpperCase();
+                else if (rest[i] === '--promo' && rest[i + 1])
+                    promoCode = rest[++i];
+            }
+            print(await client.v1Request('POST', `/agent/gigs/${encodeURIComponent(rest[2])}/order`, { tier, ...(promoCode ? { promoCode } : {}) }));
+            return;
+        }
+        if (sub === 'offer' && rest[2]) {
+            let buyerId = '';
+            let amount = NaN;
+            let deliveryDays;
+            let description;
+            let idempotencyKey;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--to' && rest[i + 1])
+                    buyerId = rest[++i];
+                else if (rest[i] === '--amount' && rest[i + 1])
+                    amount = Number(rest[++i]);
+                else if (rest[i] === '--days' && rest[i + 1])
+                    deliveryDays = Number(rest[++i]);
+                else if (rest[i] === '--note' && rest[i + 1])
+                    description = rest[++i];
+                else if (rest[i] === '--idempotency-key' && rest[i + 1])
+                    idempotencyKey = rest[++i];
+            }
+            if (!buyerId || !Number.isFinite(amount))
+                err('gigs offer <gigId> --to <buyerUserId> --amount <usd> [--days N] [--note <text>]');
+            print(await client.v1Request('POST', `/agent/gigs/${encodeURIComponent(rest[2])}/offers`, {
+                buyerId,
+                amount,
+                ...(deliveryDays ? { deliveryDays } : {}),
+                ...(description ? { description } : {}),
+                ...(idempotencyKey ? { idempotencyKey } : {}),
+            }));
+            return;
+        }
+        err('gigs: use "gigs list", "gigs get <gigId>", "gigs patch <gigId> --body \'<json>\'", "gigs delete <gigId>", "gigs create --body \'<json>\'", "gigs order <gigId> [--tier T]" or "gigs offer <gigId> --to <userId> --amount N"');
+    }
+    if (cmd === 'media') {
+        const sub = rest[1];
+        const targets = ['job', 'gig', 'product', 'portfolio', 'avatar', 'cover', 'chat', 'order'];
+        const usage = 'media upload --file <path> --target job|gig|product|portfolio|avatar|cover|chat|order [--order <orderId>] [--label <text>]';
+        if (sub === 'upload') {
+            let filePath = '';
+            let target = '';
+            let orderId = '';
+            let label = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--file' && rest[i + 1])
+                    filePath = rest[++i];
+                else if (rest[i] === '--target' && rest[i + 1])
+                    target = rest[++i];
+                else if (rest[i] === '--order' && rest[i + 1])
+                    orderId = rest[++i];
+                else if (rest[i] === '--label' && rest[i + 1])
+                    label = rest[++i];
+            }
+            if (!filePath || !target)
+                err(usage);
+            if (!targets.includes(target))
+                err(`media upload --target must be one of ${targets.join(', ')}`);
+            if (target === 'order' && !orderId)
+                err('media upload --target order needs --order <orderId> (seller deliverable)');
+            print(await uploadAgentMediaFile({
+                baseUrl: requireBase(g),
+                apiKey: requireKey(g),
+                filePath,
+                target: target,
+                orderId: orderId || undefined,
+                label: label || undefined,
+            }));
+            return;
+        }
+        err(`media: use "${usage}"`);
+    }
+    if (cmd === 'launchpad') {
+        let prompt = '';
+        let language = 'en';
+        let messages;
+        let draft;
+        let media;
+        let structuredAnswer;
+        let editingGigId = '';
+        let editingJobId = '';
+        let sessionId = '';
+        let requestId = '';
+        let projectName = '';
+        let projectInstructions = '';
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--prompt' && rest[i + 1])
+                prompt = rest[++i];
+            else if (rest[i] === '--language' && rest[i + 1])
+                language = rest[++i];
+            else if (rest[i] === '--messages-json' && rest[i + 1]) {
+                messages = parseJsonOption('--messages-json', rest[++i]);
+            }
+            else if (rest[i] === '--draft-json' && rest[i + 1]) {
+                draft = parseJsonOption('--draft-json', rest[++i]);
+            }
+            else if (rest[i] === '--structured-answer-json' && rest[i + 1]) {
+                structuredAnswer = parseJsonOption('--structured-answer-json', rest[++i]);
+            }
+            else if (rest[i] === '--media-json' && rest[i + 1]) {
+                media = parseJsonOption('--media-json', rest[++i]);
+            }
+            else if (rest[i] === '--session-id' && rest[i + 1]) {
+                sessionId = rest[++i];
+            }
+            else if (rest[i] === '--request-id' && rest[i + 1]) {
+                requestId = rest[++i];
+            }
+            else if (rest[i] === '--project-name' && rest[i + 1])
+                projectName = rest[++i];
+            else if (rest[i] === '--project-instructions' && rest[i + 1])
+                projectInstructions = rest[++i];
+            else if (rest[i] === '--editing-gig-id' && rest[i + 1])
+                editingGigId = rest[++i];
+            else if (rest[i] === '--editing-job-id' && rest[i + 1])
+                editingJobId = rest[++i];
+        }
+        if (!prompt && !messages?.length && !draft && !editingGigId && !editingJobId) {
+            err('launchpad needs --prompt, --messages-json, --draft-json, --editing-gig-id, or --editing-job-id (plus optional flags)');
+        }
+        print(await client.launchpad({
+            prompt: prompt || undefined,
+            language,
+            messages,
+            draft,
+            project: projectName ? { name: projectName, instructions: projectInstructions || undefined } : undefined,
+            media,
+            sessionId: sessionId || undefined,
+            requestId: requestId || undefined,
+            structuredAnswer,
+            editingGigId: editingGigId || undefined,
+            editingJobId: editingJobId || undefined,
+        }));
+        return;
+    }
+    if (cmd === 'proposals') {
+        if (rest[1] === 'list') {
+            if (rest.includes('--received')) {
+                print(await client.listReceivedProposals({ status: popt('--status') ?? 'open' }));
+                return;
+            }
+            print(await client.listMyProposals());
+            return;
+        }
+        if (rest[1] === 'submit') {
+            let jobId = '';
+            let price = NaN;
+            let minutes = NaN;
+            let message = '';
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--job' && rest[i + 1])
+                    jobId = rest[++i];
+                else if (rest[i] === '--price' && rest[i + 1])
+                    price = Number(rest[++i]);
+                else if (rest[i] === '--minutes' && rest[i + 1])
+                    minutes = Number(rest[++i]);
+                else if (rest[i] === '--message' && rest[i + 1])
+                    message = rest[++i];
+            }
+            if (!jobId || !Number.isFinite(price) || !Number.isFinite(minutes) || !message) {
+                err('proposals submit --job <id> --price <n> --minutes <n> --message <text> [--idempotency-key <key>]');
+            }
+            print(await client.submitProposal({
+                jobId,
+                price,
+                deliveryTimeMinutes: minutes,
+                message,
+                idempotencyKey: takeIdempotencyKey(rest, 2),
+            }));
+            return;
+        }
+        if (rest[1] === 'accept' && rest[2]) {
+            requireKey(g);
+            let paymentMethod;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--payment-method' && rest[i + 1])
+                    paymentMethod = rest[++i];
+            }
+            print(await client.acceptProposal(rest[2], {
+                ...(paymentMethod ? { paymentMethod } : {}),
+                idempotencyKey: takeIdempotencyKey(rest, 3),
+            }));
+            return;
+        }
+        err('proposals: use "proposals list", "proposals submit …", or "proposals accept <proposalId> [--payment-method WALLET]"');
+    }
+    if (cmd === 'deliver') {
+        let jobId = '';
+        let resultText = '';
+        let resultFileUrl;
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--job' && rest[i + 1])
+                jobId = rest[++i];
+            else if (rest[i] === '--text' && rest[i + 1])
+                resultText = rest[++i];
+            else if (rest[i] === '--file-url' && rest[i + 1])
+                resultFileUrl = rest[++i];
+        }
+        if (!jobId || !resultText) {
+            err('deliver --job <jobId> --text <text> [--file-url <url>] [--idempotency-key <key>]');
+        }
+        print(await client.deliver({
+            jobId,
+            resultText,
+            resultFileUrl: resultFileUrl ?? null,
+            idempotencyKey: takeIdempotencyKey(rest, 1),
+        }));
+        return;
+    }
+    if (cmd === 'orders' && rest[1] && rest[1] !== 'list') {
+        const sub = rest[1];
+        const id = rest[2];
+        if (!id)
+            err(`orders ${sub} <orderId> …`);
+        const path = `/agent/marketplace-orders/${encodeURIComponent(id)}`;
+        const opt = (name) => {
+            const i = rest.indexOf(name, 3);
+            return i > 0 && rest[i + 1] ? rest[i + 1] : undefined;
+        };
+        if (sub === 'get')
+            return print(await client.v1Request('GET', path));
+        if (sub === 'pay') {
+            const idempotencyKey = opt('--idempotency-key') ?? `cli-pay-${id}`;
+            return print(await client.v1Request('POST', `${path}/pay-wallet`, { idempotencyKey }));
+        }
+        if (sub === 'requirements') {
+            const requirements = opt('--text');
+            const answersRaw = opt('--answers');
+            if (!requirements && !answersRaw) {
+                err('orders requirements <orderId> --text <what you need> [--answers \'[{"questionId":"…","answer":"…"}]\']');
+            }
+            return print(await client.v1Request('POST', `${path}/requirements`, {
+                requirements: requirements ?? '',
+                ...(answersRaw ? { answers: JSON.parse(answersRaw) } : {}),
+            }));
+        }
+        if (sub === 'deliver') {
+            const message = opt('--text');
+            const fileUrl = opt('--file-url');
+            if (!message && !fileUrl)
+                err('orders deliver <orderId> --text <message> [--file-url <https url>]');
+            return print(await client.v1Request('POST', `${path}/deliver`, {
+                message: message ?? '',
+                files: fileUrl ? [{ url: fileUrl, label: opt('--label') ?? (fileUrl.split('/').pop() || 'delivery') }] : [],
+            }));
+        }
+        if (sub === 'accept') {
+            const rating = Number(opt('--rating'));
+            if (!Number.isInteger(rating) || rating < 1 || rating > 5) {
+                err('orders accept <orderId> --rating 1-5 [--review <text>]   (agents must rate the seller when accepting)');
+            }
+            return print(await client.v1Request('POST', `${path}/accept`, { rating, review: opt('--review') }));
+        }
+        if (sub === 'revision') {
+            const message = opt('--text');
+            if (!message)
+                err('orders revision <orderId> --text <what to change>');
+            return print(await client.v1Request('POST', `${path}/revision`, { message }));
+        }
+        if (sub === 'rate') {
+            const rating = Number(opt('--rating'));
+            if (!Number.isFinite(rating))
+                err('orders rate <orderId> --rating 1-5 [--review <text>]');
+            return print(await client.v1Request('POST', `${path}/rate`, { rating, review: opt('--review') }));
+        }
+        if (sub === 'cancel')
+            return print(await client.v1Request('POST', `${path}/cancel`, { reason: opt('--reason') }));
+        if (sub === 'checkout')
+            return print(await client.v1Request('POST', `${path}/checkout`, {}));
+        if (sub === 'resolutions')
+            return print(await client.v1Request('GET', `${path}/resolution-request`));
+        if (sub === 'resolve') {
+            const t = (opt('--type') ?? '').toLowerCase();
+            const type = t === 'cancel' ? 'CANCEL' : t === 'partial-refund' ? 'PARTIAL_REFUND' : t === 'extend' ? 'EXTEND_DEADLINE' : '';
+            if (!type)
+                err('orders resolve <orderId> --type cancel|partial-refund|extend [--amount N] [--days N] [--message <text>]');
+            return print(await client.v1Request('POST', `${path}/resolution-request`, {
+                type,
+                ...(opt('--amount') ? { amount: Number(opt('--amount')) } : {}),
+                ...(opt('--days') ? { days: Number(opt('--days')) } : {}),
+                ...(opt('--message') ? { message: opt('--message') } : {}),
+            }));
+        }
+        if (sub === 'resolve-respond') {
+            const requestId = rest[3];
+            const action = rest[4];
+            if (!requestId || (action !== 'accept' && action !== 'decline'))
+                err('orders resolve-respond <orderId> <requestId> accept|decline');
+            return print(await client.v1Request('POST', `${path}/resolution-request/${encodeURIComponent(requestId)}/respond`, { action }));
+        }
+        if (sub === 'messages')
+            return print(await client.v1Request('GET', `${path}/messages`));
+        if (sub === 'message') {
+            const content = opt('--text');
+            if (!content)
+                err('orders message <orderId> --text <text> [--image-url <url>]');
+            return print(await client.v1Request('POST', `${path}/messages`, { content, ...(opt('--image-url') ? { imageUrl: opt('--image-url') } : {}) }));
+        }
+        if (sub === 'tip') {
+            const amount = Number(opt('--amount'));
+            if (!Number.isFinite(amount))
+                err('orders tip <orderId> --amount N [--note <text>] [--idempotency-key K]');
+            return print(await client.v1Request('POST', `${path}/tip`, {
+                amount,
+                note: opt('--note'),
+                idempotencyKey: opt('--idempotency-key') ?? `cli-tip-${id}-${amount}-${Math.floor(Date.now() / 60000)}`,
+            }));
+        }
+        if (sub === 'reorder')
+            return print(await client.v1Request('POST', `${path}/reorder`, { promoCode: opt('--promo') }));
+        if (sub === 'invoice') {
+            if (rest.includes('--html'))
+                return agentV1FetchText(g, `/api/v1${path}/invoice?format=html`);
+            return print(await client.v1Request('GET', `${path}/invoice`));
+        }
+        if (sub === 'rate-buyer') {
+            const rating = Number(opt('--rating'));
+            if (!Number.isFinite(rating))
+                err('orders rate-buyer <orderId> --rating 1-5 [--review <text>]');
+            return print(await client.v1Request('POST', `${path}/rate-buyer`, { rating, review: opt('--review') }));
+        }
+        if (sub === 'confirm-payment') {
+            const sessionId = opt('--session');
+            if (!sessionId)
+                err('orders confirm-payment <orderId> --session <stripeCheckoutSessionId>');
+            return print(await client.v1Request('POST', `${path}/confirm-payment`, { sessionId }));
+        }
+        if (sub === 'dispute') {
+            const reason = opt('--reason');
+            if (!reason)
+                err('orders dispute <orderId> --reason <what went wrong> [--evidence-url <https url>]');
+            const evidenceUrl = opt('--evidence-url');
+            return print(await client.v1Request('POST', `${path}/dispute`, {
+                reason,
+                ...(evidenceUrl ? { evidence: [{ url: evidenceUrl }] } : {}),
+            }));
+        }
+        err('orders: use list | get | pay | requirements | deliver | accept | revision | rate | cancel | dispute | checkout | resolutions | resolve | resolve-respond | message | messages | tip | reorder | invoice | rate-buyer <orderId>');
+    }
+    if (cmd === 'inquiries') {
+        const sub = rest[1];
+        const opt = (name) => {
+            const i = rest.indexOf(name, 2);
+            return i > 0 && rest[i + 1] ? rest[i + 1] : undefined;
+        };
+        if (!sub || sub === 'list')
+            return print(await client.v1Request('GET', '/agent/inquiries'));
+        if (sub === 'start') {
+            // --to takes a user id (cuid) or a public handle; "@leote" and "leote" are both sent as recipientHandle.
+            const to = opt('--to');
+            const content = opt('--text');
+            if (!to || !content)
+                err('inquiries start --to <userId|@handle|handle> --text <message> [--gig <gigId>]');
+            const isUserId = /^c[a-z0-9]{20,32}$/.test(to);
+            const recipient = isUserId ? { recipientId: to } : { recipientHandle: to.startsWith('@') ? to : `@${to}` };
+            return print(await client.v1Request('POST', '/agent/inquiries', { ...recipient, content, gigId: opt('--gig') ?? null }));
+        }
+        const id = rest[2];
+        if (!id)
+            err('inquiries get|send|accept|decline <inquiryId> …');
+        const path = `/agent/inquiries/${encodeURIComponent(id)}`;
+        if (sub === 'get')
+            return print(await client.v1Request('GET', path));
+        if (sub === 'send') {
+            const content = opt('--text');
+            const imageUrl = opt('--image-url');
+            if (!content && !imageUrl)
+                err('inquiries send <inquiryId> --text <message> [--image-url <url>]');
+            return print(await client.v1Request('POST', `${path}/messages`, { content: content ?? '', ...(imageUrl ? { imageUrl } : {}) }));
+        }
+        if (sub === 'accept' || sub === 'decline')
+            return print(await client.v1Request('PATCH', path, { action: sub }));
+        err('inquiries: use list | start | get | send | accept | decline');
+    }
+    if (cmd === 'orders' && rest[1] === 'list') {
+        let status;
+        let limit;
+        let offset;
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--status' && rest[i + 1])
+                status = rest[++i];
+            else if (rest[i] === '--limit' && rest[i + 1])
+                limit = Number(rest[++i]);
+            else if (rest[i] === '--offset' && rest[i + 1])
+                offset = Number(rest[++i]);
+        }
+        print(await client.listOrders({ status, limit, offset }));
+        return;
+    }
+    if (cmd === 'activity') {
+        if (rest[1] === 'summary')
+            return print(await client.getActivitySummary());
+        if (rest[1] && !rest[1].startsWith('--'))
+            err('activity: use [--since T] [--kind K] [--channel C] [--status S] [--limit N] [--cursor C] | summary');
+        const limit = flagValue(rest, '--limit', 1);
+        return print(await client.getActivity({
+            since: flagValue(rest, '--since', 1),
+            kind: flagValue(rest, '--kind', 1),
+            channel: flagValue(rest, '--channel', 1),
+            status: flagValue(rest, '--status', 1),
+            cursor: flagValue(rest, '--cursor', 1),
+            ...(limit ? { limit: Number(limit) } : {}),
+        }));
+    }
+    if (cmd === 'engagements' || cmd === 'subscriptions' || cmd === 'sub-jobs' || cmd === 'team' || cmd === 'teams') {
+        await runSubscriptionCommand(g, rest, client);
+        return;
+    }
+    if (cmd === 'dismiss-order' && rest[1]) {
+        print(await agentV1Fetch(g, `/api/v1/agent/marketplace-orders/${encodeURIComponent(rest[1])}/dismiss`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        }));
+        return;
+    }
+    if (cmd === 'marketplace-orders') {
+        const params = {};
+        for (let i = 1; i < rest.length; i++) {
+            if (rest[i] === '--status' && rest[i + 1])
+                params.status = rest[++i];
+            else if (rest[i] === '--limit' && rest[i + 1])
+                params.limit = rest[++i];
+            else if ((rest[i] === '--page' || rest[i] === '--offset') && rest[i + 1])
+                params.page = rest[++i];
+            else if (rest[i] === '--role' && rest[i + 1])
+                params.role = rest[++i];
+        }
+        print(await client.marketplaceOrders(Object.keys(params).length ? params : undefined));
+        return;
+    }
+    if (cmd === 'revise' && rest[1]) {
+        const i = rest.indexOf('--text');
+        const message = i > 0 ? rest[i + 1] : undefined;
+        if (!message)
+            err('revise <jobId> --text <what to change>');
+        print(await client.v1Request('POST', `/agent/jobs/${encodeURIComponent(rest[1])}/reject-delivery`, { message }));
+        return;
+    }
+    if (cmd === 'complete' && rest[1]) {
+        const jobId = rest[1];
+        let rating;
+        let review;
+        for (let i = 2; i < rest.length; i++) {
+            if (rest[i] === '--rating' && rest[i + 1])
+                rating = Number(rest[++i]);
+            else if (rest[i] === '--review' && rest[i + 1])
+                review = rest[++i];
+        }
+        if (rating == null || !Number.isInteger(rating) || rating < 1 || rating > 5) {
+            err('complete <jobId> --rating 1-5 [--review <text>]   (agents must rate the seller)');
+        }
+        print(await client.completeOwnJob(jobId, {
+            rating,
+            review,
+            idempotencyKey: takeIdempotencyKey(rest, 2),
+        }));
+        return;
+    }
+    if (cmd === 'favorites') {
+        requireKey(g);
+        const sub = rest[1] || 'list';
+        const parseTarget = () => {
+            const body = {};
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--job' && rest[i + 1])
+                    body.jobId = rest[++i];
+                else if (rest[i] === '--gig' && rest[i + 1])
+                    body.gigId = rest[++i];
+                else if (rest[i] === '--agent' && rest[i + 1])
+                    body.agentUserId = rest[++i];
+                else if (rest[i] === '--product' && rest[i + 1])
+                    body.productId = rest[++i];
+                else if (rest[i] === '--slug' && rest[i + 1])
+                    body.productSlug = rest[++i];
+            }
+            return body;
+        };
+        if (sub === 'list') {
+            let type;
+            let direction;
+            for (let i = 2; i < rest.length; i++) {
+                if (rest[i] === '--type' && rest[i + 1])
+                    type = rest[++i];
+                else if (rest[i] === '--direction' && rest[i + 1])
+                    direction = rest[++i];
+            }
+            print(await client.listFavorites({ type, direction }));
+            return;
+        }
+        if (sub === 'save') {
+            const body = parseTarget();
+            if (Object.keys(body).length !== 1)
+                err('favorites save --job|--gig|--agent|--product|--slug <id>');
+            print(await client.saveFavorite(body));
+            return;
+        }
+        if (sub === 'delete') {
+            const body = parseTarget();
+            if (Object.keys(body).length !== 1)
+                err('favorites delete --job|--gig|--agent|--product|--slug <id>');
+            print(await client.deleteFavorite(body));
+            return;
+        }
+        err('favorites: list | save | delete');
+    }
+    if (cmd === 'conversations') {
+        requireKey(g);
+        const sub = rest[1] || 'list';
+        if (sub === 'list') {
+            print(await client.listConversations());
+            return;
+        }
+        if (sub === 'messages' && rest[2]) {
+            let limit;
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--limit' && rest[i + 1])
+                    limit = Number(rest[++i]);
+            }
+            print(await client.getMessages(rest[2], { limit }));
+            return;
+        }
+        if (sub === 'send' && rest[2]) {
+            let text = '';
+            let receiverId = '';
+            let imageUrl = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--text' && rest[i + 1])
+                    text = rest[++i];
+                else if (rest[i] === '--receiver' && rest[i + 1])
+                    receiverId = rest[++i];
+                else if (rest[i] === '--image-url' && rest[i + 1])
+                    imageUrl = rest[++i];
+            }
+            if (!text && !imageUrl)
+                err('conversations send <jobId> --text <text> [--image-url <url from media upload --target chat>] [--receiver <userId>]');
+            print(await client.sendMessage(rest[2], {
+                content: text,
+                receiverId: receiverId || undefined,
+                ...(imageUrl ? { imageUrl } : {}),
+            }));
+            return;
+        }
+        if (sub === 'offer' && rest[2]) {
+            let to = '';
+            let amount = 0;
+            let description = '';
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--to' && rest[i + 1])
+                    to = rest[++i];
+                else if (rest[i] === '--amount' && rest[i + 1])
+                    amount = Number(rest[++i]);
+                else if (rest[i] === '--description' && rest[i + 1])
+                    description = rest[++i];
+            }
+            if (!to || !Number.isFinite(amount) || amount <= 0) {
+                err('conversations offer <jobId> --to <userId> --amount N [--description <text>]');
+            }
+            print(await client.createChatOffer(rest[2], { amount, receiverId: to, description: description || undefined }));
+            return;
+        }
+        if (sub === 'offer-respond' && rest[2]) {
+            let offerId = '';
+            let action = '';
+            let paymentMethod;
+            const idempotencyKey = takeIdempotencyKey(rest, 3);
+            for (let i = 3; i < rest.length; i++) {
+                if (rest[i] === '--offer' && rest[i + 1])
+                    offerId = rest[++i];
+                else if (rest[i] === '--action' && rest[i + 1])
+                    action = rest[++i];
+                else if (rest[i] === '--payment-method' && rest[i + 1]) {
+                    paymentMethod = rest[++i];
+                }
+            }
+            if (!offerId || (action !== 'accept' && action !== 'reject')) {
+                err('conversations offer-respond <jobId> --offer <id> --action accept|reject');
+            }
+            print(await client.respondToChatOffer(rest[2], {
+                offerId,
+                action,
+                paymentMethod,
+                idempotencyKey,
+            }));
+            return;
+        }
+        if (sub === 'archive' && rest[2]) {
+            print(await client.archiveConversation(rest[2]));
+            return;
+        }
+        if (sub === 'unarchive' && rest[2]) {
+            print(await client.unarchiveConversation(rest[2]));
+            return;
+        }
+        err('conversations: list | messages | send | offer | offer-respond | archive | unarchive');
+    }
+    if (cmd === 'raw' && rest[1] && rest[2]) {
+        const method = rest[1];
+        const path = rest[2].startsWith('/') ? rest[2] : `/${rest[2]}`;
+        let body = undefined;
+        for (let i = 3; i < rest.length; i++) {
+            if (rest[i] === '--body' && rest[i + 1]) {
+                try {
+                    body = JSON.parse(rest[++i]);
+                }
+                catch {
+                    err('raw --body must be valid JSON');
+                }
+            }
+        }
+        print(await client.v1Request(method, path, body));
+        return;
+    }
+    err(`Unknown command: ${cmd}. Run agentchain --help.`);
+}
+main().catch((e) => {
+    console.error(formatApiError(e));
+    process.exit(1);
+});