@0xwork/cli 0.2.0 → 1.0.1

package/package.json

@@ -1,21 +1,46 @@
 {
   "name": "@0xwork/cli",
-  "version": "0.2.0",
-  "description": "0xWork CLI — Connect your AI agent to the 0xWork marketplace. Discover tasks, claim work, submit deliverables, earn USDC.",
+  "version": "1.0.1",
+  "description": "0xWork CLI — AI agents earn money on-chain. Discover tasks, claim work, submit deliverables, earn USDC.",
   "bin": {
     "0xwork": "./bin/0xwork.js"
   },
-  "keywords": ["0xwork", "ai-agent", "cli", "base", "usdc", "crypto", "marketplace", "agent"],
-  "author": "Axel Labs Inc.",
+  "main": "src/index.js",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node test/smoke.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "ora": "^5.4.1"
+  },
+  "peerDependencies": {
+    "@0xwork/sdk": ">=0.5.0"
+  },
+  "keywords": [
+    "0xwork",
+    "ai-agent",
+    "cli",
+    "base",
+    "usdc",
+    "crypto",
+    "marketplace",
+    "autonomous-agent"
+  ],
+  "author": "0xWork",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JKILLR/0xwork"
+    "url": "https://github.com/JKILLR/0xwork",
+    "directory": "cli"
   },
   "homepage": "https://0xwork.org",
-  "dependencies": {
-    "@0xwork/sdk": "^0.5.0"
-  },
   "engines": {
     "node": ">=18"
   }

package/src/commands/abandon.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint, warn } = require('../output');
+const { createSpinner } = require('../spinner');
+
+function register(program) {
+  program
+    .command('abandon <chainTaskId>')
+    .description('Abandon a claimed task (50% stake penalty)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'abandon',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      message: `DRY RUN: Would abandon task #${taskId} (50% stake penalty)`,
+    }, () => {
+      header('⚠️', `Abandon Task #${taskId} — Dry Run`);
+      hint('Set PRIVATE_KEY in .env to abandon tasks.');
+      blank();
+    });
+  }
+
+  const sdk = requireSDK();
+
+  const s = createSpinner('Abandoning task…');
+  s.start();
+
+  const result = await sdk.abandonTask(parseInt(taskId));
+
+  s.succeed('Abandoned');
+
+  success({
+    command: 'abandon',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    message: `Abandoned task #${taskId} — 50% stake slashed`,
+  }, () => {
+    header('⚠️', `Task #${taskId} Abandoned`);
+    warn(chalk.yellow('50% of your stake has been slashed.'));
+    blank();
+    hint(`tx: ${result.txHash}`);
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/approve.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, truncAddr } = require('../format');
+
+function register(program) {
+  program
+    .command('approve <chainTaskId>')
+    .description('Approve submitted work and release USDC to worker')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'approve', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would approve task #${taskId}`,
+    }, () => {
+      header('✅', `Approve #${taskId} — Dry Run`);
+      hint('Set PRIVATE_KEY in .env.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const address = sdk.address;
+
+  const s1 = createSpinner('Checking task…');
+  s1.start();
+
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Submitted' && onChain.state !== 'Disputed') {
+    s1.fail(`Task is ${onChain.state}`);
+    fail(`Task #${taskId} is ${onChain.state}, expected Submitted or Disputed`);
+  }
+  if (onChain.poster.toLowerCase() !== address.toLowerCase()) {
+    s1.fail('Not your task');
+    fail(`Only the poster can approve. Poster: ${onChain.poster}, You: ${address}`);
+  }
+
+  s1.succeed('Verified');
+
+  const s2 = createSpinner('Approving…');
+  s2.start();
+  const result = await sdk.approveWork(parseInt(taskId));
+  s2.succeed('Approved');
+
+  const bounty = parseFloat(onChain.bountyAmount);
+  const fee = onChain.discountedFee ? bounty * 0.02 : bounty * 0.05;
+  const payout = bounty - fee;
+
+  success({
+    command: 'approve', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, worker: onChain.worker,
+    bounty: onChain.bountyAmount, fee: fee.toFixed(2), payout: payout.toFixed(2),
+    message: `Approved task #${taskId} — ${fmtBounty(payout)} released to ${onChain.worker}`,
+  }, () => {
+    header('✔', `Task #${taskId} Approved`);
+    keyValue('Worker', truncAddr(onChain.worker));
+    keyValue('Payout', chalk.green.bold(`${fmtBounty(payout)} USDC`));
+    keyValue('Fee', chalk.dim(`${fmtBounty(fee)} (${onChain.discountedFee ? '2%' : '5%'})`));
+    blank();
+    hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/auto-resolve.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtDuration, truncAddr } = require('../format');
+
+function register(program) {
+  program
+    .command('auto-resolve <chainTaskId>')
+    .description('Trigger dispute auto-resolve after 48h (worker wins)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'auto-resolve', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would trigger auto-resolve on task #${taskId}`,
+    }, () => {
+      header('⚖️', `Auto-Resolve #${taskId} — Dry Run`); hint('Set PRIVATE_KEY.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+
+  const s1 = createSpinner('Checking task…');
+  s1.start();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Disputed') {
+    s1.fail(`Task is ${onChain.state}`); fail('Expected Disputed state');
+  }
+  if (!onChain.disputeTimestamp) {
+    s1.fail('No dispute timestamp'); fail('No dispute timestamp recorded.');
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const window = 48 * 3600;
+  const eligibleAt = onChain.disputeTimestamp + window;
+  if (now < eligibleAt) {
+    const remaining = eligibleAt - now;
+    s1.fail('Not yet eligible');
+    fail(`Auto-resolve eligible in ${fmtDuration(remaining)} (at ${new Date(eligibleAt * 1000).toISOString()})`);
+  }
+  s1.succeed('Eligible');
+
+  const s2 = createSpinner('Resolving dispute…');
+  s2.start();
+  const result = await sdk.autoResolveDispute(parseInt(taskId));
+  s2.succeed('Resolved — worker wins');
+
+  const bounty = parseFloat(onChain.bountyAmount);
+  const fee = onChain.discountedFee ? bounty * 0.02 : bounty * 0.05;
+  const payout = bounty - fee;
+
+  success({
+    command: 'auto-resolve', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, worker: onChain.worker, payout: payout.toFixed(2),
+    message: `Dispute auto-resolved on task #${taskId} — worker wins`,
+  }, () => {
+    header('✔', `Dispute Resolved — Task #${taskId}`);
+    keyValue('Winner', chalk.green('Worker') + ` (${truncAddr(onChain.worker)})`);
+    keyValue('Payout', chalk.green.bold(`${fmtBounty(payout)} USDC`));
+    hint('Poster stake slashed.');
+    blank(); hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/balance.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { getEthers, getSDK, isDryRun, resolveAddress, getConstants, normalizeError } = require('../sdk');
+const { success, fail, header, blank, divider } = require('../output');
+const { createSpinner } = require('../spinner');
+const { getAxobotlPrice, formatAxobotlUsd } = require('../price');
+const { fmtAxobotl, truncAddr } = require('../format');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('balance')
+    .description('Check wallet balances ($AXOBOTL, USDC, ETH)')
+    .option('--address <addr>', 'Wallet address (defaults to .env)')
+    .action(async (opts) => {
+      try {
+        await run(opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(opts) {
+  const address = resolveAddress(opts.address);
+  const ethers = getEthers();
+  const provider = config.PRIVATE_KEY
+    ? getSDK().provider
+    : new ethers.JsonRpcProvider(config.RPC_URL);
+
+  const constants = getConstants();
+  const ERC20_ABI = ['function balanceOf(address) view returns (uint256)'];
+
+  const spinner = createSpinner('Fetching balances…');
+  spinner.start();
+
+  const axobotl = new ethers.Contract(constants.ADDRESSES.AXOBOTL, ERC20_ABI, provider);
+  const usdc    = new ethers.Contract(constants.ADDRESSES.USDC, ERC20_ABI, provider);
+  const registry = new ethers.Contract(constants.ADDRESSES.AGENT_REGISTRY, constants.AGENT_REGISTRY_ABI, provider);
+
+  const [ab, ub, eb] = await Promise.all([
+    axobotl.balanceOf(address),
+    usdc.balanceOf(address),
+    provider.getBalance(address),
+  ]);
+
+  // Check staked amount
+  let stakedAmount = '0.0';
+  try {
+    const [found, agentId] = await registry.getAgentByOperator(address);
+    if (found) {
+      const agent = await registry.getAgent(agentId);
+      stakedAmount = ethers.formatUnits(agent.stakedAmount, 18);
+    } else {
+      const resp = await fetchWithTimeout(`${config.API_URL}/agents/${address}`);
+      if (resp.ok) {
+        const data = await resp.json();
+        const agent = data.agent || data;
+        if (agent && agent.staked_amount) stakedAmount = ethers.formatUnits(agent.staked_amount, 18);
+      }
+    }
+  } catch { /* not registered */ }
+
+  const walletBalance = ethers.formatUnits(ab, 18);
+  const totalAxobotl = (parseFloat(walletBalance) + parseFloat(stakedAmount)).toFixed(4);
+  const usdcBalance = ethers.formatUnits(ub, 6);
+  const ethBalance = ethers.formatEther(eb);
+
+  const price = await getAxobotlPrice();
+
+  spinner.stop();
+
+  const balances = {
+    axobotl: walletBalance,
+    axobotlStaked: stakedAmount,
+    axobotlTotal: totalAxobotl,
+    usdc: usdcBalance,
+    eth: ethBalance,
+  };
+
+  if (price) {
+    balances.axobotlUsd = formatAxobotlUsd(walletBalance, price);
+    balances.axobotlStakedUsd = formatAxobotlUsd(stakedAmount, price);
+    balances.axobotlTotalUsd = formatAxobotlUsd(totalAxobotl, price);
+    balances.axobotlPriceUsd = price;
+  }
+
+  success({
+    command: 'balance',
+    dryRun: isDryRun(),
+    address,
+    balances,
+  }, () => {
+    header('💰', 'Wallet', chalk.dim(truncAddr(address)));
+
+    const pad = (label) => chalk.dim(label.padEnd(12));
+
+    console.log(`    ${pad('ETH')}${parseFloat(ethBalance).toFixed(6)}`);
+    console.log(`    ${pad('USDC')}${chalk.green('$' + parseFloat(usdcBalance).toFixed(2))}`);
+    console.log(`    ${pad('$AXOBOTL')}${fmtAxobotl(walletBalance)}${price ? chalk.dim(`  ~${formatAxobotlUsd(walletBalance, price)}`) : ''}`);
+    console.log(`    ${pad('Staked')}${fmtAxobotl(stakedAmount)}${price ? chalk.dim(`  ~${formatAxobotlUsd(stakedAmount, price)}`) : ''}`);
+    divider(35);
+
+    // Total: only assets we can price reliably (USDC + AXOBOTL if price known)
+    const totalUsd = parseFloat(usdcBalance) +
+      (price ? parseFloat(totalAxobotl) * price : 0);
+    if (totalUsd > 0) {
+      console.log(`    ${pad('Total')}${chalk.bold(`~$${totalUsd.toFixed(2)}`)}${!price ? chalk.dim(' (excl. AXOBOTL)') : ''}`);
+    }
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/cancel.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtAxobotl } = require('../format');
+
+function register(program) {
+  program
+    .command('cancel <chainTaskId>')
+    .description('Cancel an open task (bounty + poster stake returned)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'cancel', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would cancel task #${taskId}`,
+    }, () => {
+      header('🚫', `Cancel #${taskId} — Dry Run`); hint('Set PRIVATE_KEY.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const address = sdk.address;
+
+  const s1 = createSpinner('Checking task…');
+  s1.start();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Open') {
+    s1.fail(`Task is ${onChain.state}`);
+    fail(`Task is ${onChain.state}, not Open. Use ${chalk.cyan('0xwork mutual-cancel')} for claimed/submitted tasks.`);
+  }
+  if (onChain.poster.toLowerCase() !== address.toLowerCase()) {
+    s1.fail('Not your task'); fail('Only the poster can cancel.');
+  }
+  s1.succeed('Verified');
+
+  const s2 = createSpinner('Cancelling…');
+  s2.start();
+  const result = await sdk.cancelTask(parseInt(taskId));
+  s2.succeed('Cancelled');
+
+  success({
+    command: 'cancel', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, bountyReturned: onChain.bountyAmount,
+    posterStakeReturned: onChain.posterStakeAmount,
+    message: `Cancelled task #${taskId}`,
+  }, () => {
+    header('✔', `Task #${taskId} Cancelled`);
+    keyValue('Bounty returned', chalk.green(fmtBounty(onChain.bountyAmount) + ' USDC'));
+    if (onChain.posterStakeAmount && onChain.posterStakeAmount !== '0.0') {
+      keyValue('Stake returned', `${fmtAxobotl(onChain.posterStakeAmount)} AXOBOTL`);
+    }
+    blank(); hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/claim-approval.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtDuration, truncAddr } = require('../format');
+
+function register(program) {
+  program
+    .command('claim-approval <chainTaskId>')
+    .description('Trigger auto-approve after poster ghosts 7 days')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'claim-approval', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would trigger auto-approve on task #${taskId}`,
+    }, () => {
+      header('⏱️', `Claim Approval #${taskId} — Dry Run`); hint('Set PRIVATE_KEY.'); blank();
+    });
+  }
+
+  const sdk = requireSDK();
+
+  const s1 = createSpinner('Checking task…');
+  s1.start();
+  const onChain = await sdk.getTask(parseInt(taskId));
+  if (onChain.state !== 'Submitted') {
+    s1.fail(`Task is ${onChain.state}`); fail('Expected Submitted state');
+  }
+  if (!onChain.submitTimestamp) {
+    s1.fail('No submission timestamp'); fail('No submission timestamp recorded.');
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const window = 7 * 86400;
+  const eligibleAt = onChain.submitTimestamp + window;
+  if (now < eligibleAt) {
+    const remaining = eligibleAt - now;
+    s1.fail('Not yet eligible');
+    fail(`Auto-approve eligible in ${fmtDuration(remaining)} (at ${new Date(eligibleAt * 1000).toISOString()})`);
+  }
+  s1.succeed('Eligible');
+
+  const s2 = createSpinner('Triggering auto-approve…');
+  s2.start();
+  const result = await sdk.claimApproval(parseInt(taskId));
+  s2.succeed('Auto-approved');
+
+  const bounty = parseFloat(onChain.bountyAmount);
+  const fee = onChain.discountedFee ? bounty * 0.02 : bounty * 0.05;
+  const payout = bounty - fee;
+
+  success({
+    command: 'claim-approval', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, worker: onChain.worker, payout: payout.toFixed(2),
+    message: `Auto-approved task #${taskId} — ${fmtBounty(payout)} to worker`,
+  }, () => {
+    header('✔', `Task #${taskId} Auto-Approved`);
+    keyValue('Worker', truncAddr(onChain.worker));
+    keyValue('Payout', chalk.green.bold(`${fmtBounty(payout)} USDC`));
+    hint('Poster stake slashed for inaction.');
+    blank(); hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/claim.js

@@ -0,0 +1,158 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { getEthers, isDryRun, requireSDK, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtDeadline, fmtAxobotl } = require('../format');
+const { getAxobotlPrice, formatAxobotlUsd } = require('../price');
+const { resolveTask } = require('../resolve');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('claim <chainTaskId>')
+    .description('Claim a task on-chain (stakes $AXOBOTL as collateral)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    let t;
+    try { t = await resolveTask(taskId); } catch { t = null; }
+    return success({
+      command: 'claim',
+      dryRun: true,
+      taskId: parseInt(taskId),
+      message: `DRY RUN: Would claim task #${taskId}`,
+      bounty: t ? t.bounty_amount : null,
+      stakeRaw: t ? t.stake_amount : null,
+      txHash: null,
+    }, () => {
+      header('🔒', `Claim Task #${taskId} — Dry Run`);
+      hint('Set PRIVATE_KEY in .env to claim tasks.');
+      blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  // Pre-flight: fetch on-chain state
+  const s1 = createSpinner('Checking task state…');
+  s1.start();
+
+  let onChain;
+  try {
+    onChain = await sdk.getTask(parseInt(taskId));
+  } catch (e) {
+    s1.fail('Task not found on-chain');
+    fail(`Task #${taskId} not found on-chain: ${normalizeError(e)}`);
+  }
+
+  if (onChain.poster === '0x0000000000000000000000000000000000000000') {
+    s1.fail('Task does not exist');
+    fail(`Task #${taskId} does not exist on-chain`);
+  }
+  if (onChain.state !== 'Open') {
+    s1.fail(`Task is ${onChain.state}`);
+    fail(`Task #${taskId} is not Open (current: ${onChain.state})`);
+  }
+  if (onChain.poster.toLowerCase() === address.toLowerCase()) {
+    s1.fail('Cannot claim own task');
+    fail('Cannot claim your own task');
+  }
+
+  // Preferred lock check
+  try {
+    const t = await resolveTask(taskId);
+    const lock = t.preferred_lock;
+    if (lock && lock.locked && t.preferred_agent_id != null) {
+      let myAgentId = null;
+      const agentResp = await fetchWithTimeout(`${config.API_URL}/agents/${address}`);
+      if (agentResp.ok) {
+        const agentData = await agentResp.json();
+        myAgentId = agentData.agent ? agentData.agent.chain_agent_id : null;
+      }
+      if (myAgentId == null || t.preferred_agent_id !== myAgentId) {
+        const agentName = t.preferred_agent_name || `Agent #${t.preferred_agent_id}`;
+        const hours = Math.ceil(lock.remaining_seconds / 3600);
+        s1.fail('Task is reserved');
+        fail(`Reserved for ${agentName} for ${hours}h. Try again later.`);
+      }
+    }
+  } catch (e) {
+    if (e.message && e.message.startsWith('Reserved')) throw e;
+  }
+
+  s1.succeed('Task is Open');
+
+  // Pre-flight: check balances
+  const s2 = createSpinner('Checking balances…');
+  s2.start();
+
+  const stakeRequired = await sdk.taskPool.calculateStake(
+    ethers.parseUnits(String(onChain.bountyAmount), 6)
+  );
+  const axobotlBalance = await sdk.axobotl.balanceOf(address);
+  if (axobotlBalance < stakeRequired) {
+    s2.fail('Insufficient AXOBOTL');
+    fail(
+      `Insufficient $AXOBOTL for stake`,
+      { suggestion: `Need: ${fmtAxobotl(ethers.formatUnits(stakeRequired, 18))}, Have: ${fmtAxobotl(ethers.formatUnits(axobotlBalance, 18))}. Buy on Uniswap (Base) or request from faucet.` }
+    );
+  }
+
+  const ethBalance = await sdk.provider.getBalance(address);
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    s2.fail('Insufficient ETH');
+    fail('Insufficient ETH for gas', { suggestion: `Have: ${ethers.formatEther(ethBalance)} ETH. Send ETH on Base to ${address}` });
+  }
+
+  s2.succeed('Balances OK');
+
+  // Claim
+  const s3 = createSpinner('Claiming task…');
+  s3.start();
+
+  const result = await sdk.claimTask(parseInt(taskId));
+
+  s3.succeed('Claimed');
+
+  const stakeHuman = ethers.formatUnits(stakeRequired, 18);
+  const price = await getAxobotlPrice();
+  const stakeUsd = price ? formatAxobotlUsd(stakeHuman, price) : null;
+
+  const data = {
+    command: 'claim',
+    dryRun: false,
+    taskId: parseInt(taskId),
+    txHash: result.txHash,
+    stakeAmount: stakeHuman,
+    bounty: onChain.bountyAmount,
+    message: `Claimed task #${taskId} — staked ${fmtAxobotl(stakeHuman)} AXOBOTL`,
+  };
+
+  success(data, () => {
+    header('✔', `Task #${taskId} Claimed`);
+    keyValue('Bounty', chalk.green.bold(`${fmtBounty(onChain.bountyAmount)} USDC`));
+    keyValue('Staked', `${fmtAxobotl(stakeHuman)} AXOBOTL${stakeUsd ? chalk.dim(` (~${stakeUsd})`) : ''}`);
+    keyValue('Deadline', fmtDeadline(onChain.deadline, true));
+    blank();
+    hint(`Next: complete the work, then run:`);
+    hint(`  $ 0xwork submit ${taskId} --proof="https://..."`);
+    blank();
+    hint(`tx: ${result.txHash}`);
+    blank();
+  });
+}
+
+module.exports = { register };