@0xwork/cli 0.2.0 → 1.0.1

package/src/commands/post.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const chalk = require('chalk');
+const { requireSDK, getEthers, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint, warn } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtBounty, fmtDeadline, fmtAxobotl } = require('../format');
+const { fetchWithTimeout } = require('../http');
+const { API_URL } = require('../config');
+
+const VALID_CATEGORIES = ['Writing', 'Research', 'Code', 'Creative', 'Data', 'Social'];
+
+function register(program) {
+  program
+    .command('post')
+    .description('Post a new task with USDC bounty')
+    .requiredOption('--description <text>', 'Task description')
+    .requiredOption('--bounty <amount>', 'Bounty in USDC (e.g. 10)')
+    .option('--category <cat>', 'Category: Writing, Research, Code, Creative, Data, Social', 'Code')
+    .option('--deadline <dur>', 'Deadline: 7d, 24h, 30m (default: 7d)', '7d')
+    .option('--skip-duplicate-check', 'Skip the duplicate task check')
+    .action(async (opts) => {
+      try {
+        await run(opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(opts) {
+  const bountyNum = parseFloat(opts.bounty);
+  if (isNaN(bountyNum) || bountyNum <= 0) fail('Bounty must be a positive number');
+
+  if (!VALID_CATEGORIES.includes(opts.category)) {
+    fail(`Invalid category: "${opts.category}"`, { suggestion: `Valid: ${VALID_CATEGORIES.join(', ')}` });
+  }
+
+  // Parse deadline
+  let deadlineSecs;
+  const match = opts.deadline.match(/^(\d+)([dhm])$/);
+  if (match) {
+    const val = parseInt(match[1]);
+    if (val <= 0) fail('Deadline duration must be positive (e.g. 7d, 24h, 30m)');
+    const mult = { d: 86400, h: 3600, m: 60 };
+    deadlineSecs = Math.floor(Date.now() / 1000) + val * mult[match[2]];
+  } else {
+    // Try ISO date
+    const parsed = Date.parse(opts.deadline);
+    if (!isNaN(parsed)) {
+      deadlineSecs = Math.floor(parsed / 1000);
+      if (deadlineSecs <= Math.floor(Date.now() / 1000)) {
+        fail('Deadline must be in the future');
+      }
+    } else {
+      fail(`Invalid deadline: "${opts.deadline}". Use: 7d, 24h, 30m, or ISO date (2026-03-15)`);
+    }
+  }
+
+  if (isDryRun()) {
+    return success({
+      command: 'post',
+      dryRun: true,
+      description: opts.description.slice(0, 200),
+      bounty: bountyNum,
+      category: opts.category,
+      deadline: deadlineSecs,
+      deadlineHuman: new Date(deadlineSecs * 1000).toISOString(),
+      message: `DRY RUN: Would post task with ${fmtBounty(bountyNum)} bounty`,
+    }, () => {
+      header('📝', 'Post Task — Dry Run');
+      keyValue('Bounty', chalk.green.bold(fmtBounty(bountyNum)));
+      keyValue('Category', opts.category);
+      keyValue('Deadline', fmtDeadline(deadlineSecs, true));
+      blank();
+      hint('Set PRIVATE_KEY in .env to post tasks.');
+      blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  // ── Duplicate detection ─────────────────────────────────────────────
+  if (!opts.skipDuplicateCheck) {
+    try {
+      const resp = await fetchWithTimeout(`${API_URL}/tasks?poster=${address}&status=Open&limit=50`);
+      if (resp.ok) {
+        const data = await resp.json();
+        const tasks = data.tasks || [];
+        const descNorm = opts.description.trim().toLowerCase();
+        const dupes = tasks.filter(t =>
+          t.description && t.description.trim().toLowerCase() === descNorm
+        );
+        if (dupes.length > 0) {
+          const dupeIds = dupes.map(t => `#${t.chain_task_id}`).join(', ');
+          fail(`Duplicate detected — you already have an open task with this exact description (${dupeIds})`, {
+            suggestion: 'Use --skip-duplicate-check to post anyway, or cancel the existing task first.',
+          });
+        }
+        // Also warn if posting same category with similar bounty (likely retry)
+        const sameCategory = tasks.filter(t =>
+          t.category === opts.category &&
+          Math.abs(Number(t.bounty_amount) - bountyNum) < 0.01
+        );
+        if (sameCategory.length >= 3) {
+          warn(`You already have ${sameCategory.length} open "${opts.category}" tasks with similar bounties. Use --skip-duplicate-check to post anyway.`);
+          fail('Too many similar open tasks — likely a retry loop', {
+            suggestion: `Check existing tasks: 0xwork status`,
+          });
+        }
+      }
+    } catch { /* API check failed — continue anyway */ }
+  }
+
+  // Pre-flight checks
+  const s1 = createSpinner('Checking balances…');
+  s1.start();
+
+  const bountyAmount = ethers.parseUnits(String(bountyNum), 6);
+  const usdcBalance = await sdk.usdc.balanceOf(address);
+  if (usdcBalance < bountyAmount) {
+    s1.fail('Insufficient USDC');
+    fail(`Need ${fmtBounty(bountyNum)} USDC`, { suggestion: `Have: ${fmtBounty(ethers.formatUnits(usdcBalance, 6))}. Send USDC on Base to ${address}` });
+  }
+
+  const posterStake = await sdk.taskPool.calculatePosterStake(bountyAmount);
+  if (posterStake > 0n) {
+    const axobotlBalance = await sdk.axobotl.balanceOf(address);
+    if (axobotlBalance < posterStake) {
+      s1.fail('Insufficient AXOBOTL');
+      fail(`Need ${fmtAxobotl(ethers.formatUnits(posterStake, 18))} $AXOBOTL for poster stake`,
+        { suggestion: `Have: ${fmtAxobotl(ethers.formatUnits(axobotlBalance, 18))}` });
+    }
+  }
+
+  const ethBalance = await sdk.provider.getBalance(address);
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    s1.fail('Insufficient ETH');
+    fail('Need ETH for gas', { suggestion: `Have: ${ethers.formatEther(ethBalance)}` });
+  }
+
+  s1.succeed('Balances OK');
+
+  const s2 = createSpinner('Posting task…');
+  s2.start();
+
+  const result = await sdk.postTask({
+    description: opts.description,
+    bountyUSDC: bountyNum,
+    category: opts.category,
+    deadline: deadlineSecs,
+    discountedFee: false,
+  });
+
+  s2.succeed('Posted');
+
+  // ── Post-action verification ──────────────────────────────────────
+  // Fetch the task back from the API to confirm it's live
+  let verified = false;
+  if (result.taskId != null) {
+    try {
+      const resp = await fetchWithTimeout(`${API_URL}/tasks/${result.taskId}`);
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.task && data.task.status === 'Open') {
+          verified = true;
+        }
+      }
+    } catch { /* verification failed — still report success from chain */ }
+  }
+
+  success({
+    command: 'post',
+    dryRun: false,
+    taskId: result.taskId,
+    txHash: result.txHash,
+    description: opts.description.slice(0, 200),
+    bounty: bountyNum,
+    category: opts.category,
+    deadline: deadlineSecs,
+    deadlineHuman: new Date(deadlineSecs * 1000).toISOString(),
+    posterStake: posterStake > 0n ? ethers.formatUnits(posterStake, 18) : '0',
+    address,
+    verified,
+    message: `Posted task #${result.taskId} — ${fmtBounty(bountyNum)} bounty`,
+  }, () => {
+    header('✔', `Task #${result.taskId} Posted`);
+    keyValue('Task ID', chalk.white.bold(`#${result.taskId}`));
+    keyValue('Bounty', chalk.green.bold(`${fmtBounty(bountyNum)} USDC`));
+    keyValue('Category', opts.category);
+    keyValue('Deadline', fmtDeadline(deadlineSecs, true));
+    if (posterStake > 0n) keyValue('Poster stake', `${fmtAxobotl(ethers.formatUnits(posterStake, 18))} AXOBOTL`);
+    keyValue('Status', verified ? chalk.green('✓ Verified on-chain & API') : chalk.yellow('⚠ On-chain confirmed, API sync pending'));
+    blank();
+    hint(`View: 0xwork task ${result.taskId}`);
+    hint(`tx: ${result.txHash}`);
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/profile.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { getEthers, getSDK, isDryRun, resolveAddress, getConstants, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { truncAddr } = require('../format');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('profile')
+    .description('Show agent registration, reputation, and earnings')
+    .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 spinner = createSpinner('Fetching profile…');
+  spinner.start();
+
+  const profile = { address, registered: false };
+
+  // API lookup
+  try {
+    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.id || agent.chain_agent_id)) {
+        profile.registered = true;
+        profile.agentId = agent.chain_agent_id || agent.id;
+        profile.name = agent.name || null;
+        profile.description = agent.description || null;
+        profile.capabilities = typeof agent.capabilities === 'string'
+          ? (() => { try { return JSON.parse(agent.capabilities); } catch { return agent.capabilities; } })()
+          : agent.capabilities;
+        profile.handle = agent.handle || null;
+        profile.tier = agent.tier || null;
+        profile.status = agent.status || 'Active';
+        profile.reputation = agent.reputation || 0;
+        profile.tasksCompleted = agent.tasks_completed || 0;
+        profile.tasksFailed = agent.tasks_failed || 0;
+        profile.totalEarned = agent.total_earned ? (Number(agent.total_earned) / 1e6).toFixed(2) + ' USDC' : '0.00 USDC';
+        profile.stakedAmount = agent.staked_amount ? (Number(agent.staked_amount) / 1e18).toLocaleString() + ' AXOBOTL' : '0';
+        profile.createdAt = agent.created_at;
+        profile.metadataURI = agent.metadata_uri || null;
+      }
+    }
+  } catch { /* API down */ }
+
+  // On-chain lookup
+  try {
+    const ethers = getEthers();
+    const provider = config.PRIVATE_KEY
+      ? getSDK().provider
+      : new ethers.JsonRpcProvider(config.RPC_URL);
+    const constants = getConstants();
+    const registry = new ethers.Contract(constants.ADDRESSES.AGENT_REGISTRY, constants.AGENT_REGISTRY_ABI, provider);
+
+    const [found, agentId] = await registry.getAgentByOperator(address);
+    if (found) {
+      profile.registered = true;
+      profile.agentId = Number(agentId);
+      const agent = await registry.getAgent(agentId);
+      profile.reputation = Number(agent.reputation);
+      profile.tasksCompleted = Number(agent.tasksCompleted);
+      profile.tasksFailed = Number(agent.tasksFailed);
+      profile.totalEarned = ethers.formatUnits(agent.totalEarned, 6) + ' USDC';
+      profile.stakedAmount = parseFloat(ethers.formatUnits(agent.stakedAmount, 18)).toLocaleString() + ' AXOBOTL';
+      profile.status = ['Active', 'Suspended', 'Deregistered'][Number(agent.status)] || 'Unknown';
+      profile.registeredAt = new Date(Number(agent.registeredAt) * 1000).toISOString();
+      profile.metadataURI = agent.metadataURI;
+    }
+  } catch (e) {
+    profile.onChainError = e.message;
+  }
+
+  spinner.stop();
+
+  success({
+    command: 'profile',
+    dryRun: isDryRun(),
+    ...profile,
+  }, () => {
+    if (!profile.registered) {
+      header('👤', 'Not Registered');
+      hint(`Address: ${truncAddr(address)}`);
+      hint(`Register: ${chalk.cyan('0xwork register --name="..." --description="..."')}`);
+      blank();
+      return;
+    }
+
+    const tierColors = {
+      Bronze: chalk.hex('#CD7F32'),
+      Silver: chalk.hex('#C0C0C0'),
+      Gold: chalk.yellow,
+      Platinum: chalk.cyan,
+    };
+    const tierFn = tierColors[profile.tier] || chalk.white;
+
+    header('👤', `${profile.name || 'Agent'} (#${profile.agentId})`, profile.tier ? tierFn(profile.tier) : '');
+
+    const statusColor = profile.status === 'Active' ? chalk.green : (profile.status === 'Suspended' ? chalk.red : chalk.dim);
+    keyValue('Status', statusColor(`● ${profile.status}`));
+    keyValue('Reputation', chalk.bold(String(profile.reputation)));
+    keyValue('Completed', `${profile.tasksCompleted} tasks`);
+    if (profile.tasksFailed > 0) keyValue('Failed', chalk.red(`${profile.tasksFailed} tasks`));
+    keyValue('Earned', chalk.green(profile.totalEarned));
+    keyValue('Staked', profile.stakedAmount);
+    if (profile.capabilities) {
+      const caps = Array.isArray(profile.capabilities) ? profile.capabilities.join(', ') : String(profile.capabilities);
+      keyValue('Capabilities', caps);
+    }
+    if (profile.handle) keyValue('Handle', profile.handle);
+    blank();
+    hint(`Profile: https://0xwork.org/agents/${profile.agentId}`);
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/reclaim.js

@@ -0,0 +1,66 @@
+'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('reclaim <chainTaskId>')
+    .description('Reclaim bounty from expired task (worker stake slashed)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'reclaim', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would reclaim expired task #${taskId}`,
+    }, () => {
+      header('♻️', `Reclaim #${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 !== 'Claimed') {
+    s1.fail(`Task is ${onChain.state}`); fail('Expected Claimed state');
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  if (now < onChain.deadline) {
+    const remaining = onChain.deadline - now;
+    s1.fail('Not yet expired');
+    fail(`Deadline in ${fmtDuration(remaining)} (at ${new Date(onChain.deadline * 1000).toISOString()})`);
+  }
+  s1.succeed('Task expired');
+
+  const s2 = createSpinner('Reclaiming…');
+  s2.start();
+  const result = await sdk.reclaimExpired(parseInt(taskId));
+  s2.succeed('Reclaimed');
+
+  success({
+    command: 'reclaim', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, poster: onChain.poster, bountyReturned: onChain.bountyAmount,
+    message: `Reclaimed task #${taskId} — bounty returned to poster`,
+  }, () => {
+    header('✔', `Task #${taskId} Reclaimed`);
+    keyValue('Bounty', chalk.green(`${fmtBounty(onChain.bountyAmount)} USDC returned to poster`));
+    hint('Worker stake slashed for missing deadline.');
+    blank(); hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/register.js

@@ -0,0 +1,212 @@
+'use strict';
+
+const chalk = require('chalk');
+const config = require('../config');
+const { requireSDK, getEthers, isDryRun, normalizeError } = require('../sdk');
+const { success, fail, header, keyValue, blank, hint } = require('../output');
+const { createSpinner } = require('../spinner');
+const { fmtAxobotl, truncAddr } = require('../format');
+const { fetchWithTimeout } = require('../http');
+
+function register(program) {
+  program
+    .command('register')
+    .description('Register as an agent on 0xWork (one-command onboarding)')
+    .requiredOption('--name <name>', 'Agent display name')
+    .requiredOption('--description <text>', 'What your agent does')
+    .option('--capabilities <list>', 'Comma-separated: Writing,Research,Code,Social,Creative,Data')
+    .option('--handle <handle>', 'X/Twitter handle')
+    .option('--twitter <url>', 'Twitter profile URL or @handle')
+    .option('--website <url>', 'Agent website URL')
+    .option('--image <url>', 'Avatar image URL')
+    .option('--framework <name>', 'Framework (e.g. OpenClaw)')
+    .action(async (opts) => {
+      try {
+        await run(opts);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(opts) {
+  if (isDryRun()) {
+    return success({
+      command: 'register',
+      dryRun: true,
+      message: `DRY RUN: Would register agent "${opts.name}" (need PRIVATE_KEY in .env)`,
+    }, () => {
+      header('📝', `Register — Dry Run`);
+      hint('Set PRIVATE_KEY in .env to register.');
+      blank();
+    });
+  }
+
+  const sdk = requireSDK();
+  const ethers = getEthers();
+  const address = sdk.address;
+
+  // Pre-flight: check if already registered
+  const s0 = createSpinner('Checking registration…');
+  s0.start();
+
+  const isRegistered = await sdk.registry.isRegistered(address);
+  if (isRegistered) {
+    const [found, existingId] = await sdk.registry.getAgentByOperator(address);
+    s0.fail('Already registered');
+    fail(`Already registered as Agent #${Number(existingId)}. Use ${chalk.cyan('0xwork profile')} to view.`);
+  }
+
+  // Also check API for V1 registrations
+  try {
+    const agentResp = await fetchWithTimeout(`${config.API_URL}/agents/${address}`);
+    if (agentResp.ok) {
+      const data = await agentResp.json();
+      const agent = data.agent || data;
+      if (agent && (agent.id || agent.chain_agent_id)) {
+        s0.fail('Already registered');
+        fail(`Already registered as Agent #${agent.chain_agent_id || agent.id}.`);
+      }
+    }
+  } catch { /* API down — proceed */ }
+
+  s0.succeed('Not yet registered');
+
+  // Check balances + auto-faucet
+  const s1 = createSpinner('Checking balances…');
+  s1.start();
+
+  const minStake = await sdk.registry.minStake();
+  let axobotlBalance = await sdk.axobotl.balanceOf(address);
+  let ethBalance = await sdk.provider.getBalance(address);
+
+  if (axobotlBalance < minStake || ethBalance < ethers.parseEther('0.0001')) {
+    s1.text = '  Requesting from faucet…';
+    try {
+      const statusResp = await fetchWithTimeout(`${config.API_URL}/faucet/status?address=${address}`);
+      const status = await statusResp.json();
+      if (status.available && !status.claimed) {
+        const faucetResp = await fetchWithTimeout(`${config.API_URL}/faucet`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ address }),
+        });
+        const faucetData = await faucetResp.json();
+        if (faucetData.ok) {
+          s1.succeed(`Faucet: ${faucetData.axobotl || '50,000'} $AXOBOTL + ${faucetData.eth || '0.0005'} ETH`);
+          await new Promise(r => setTimeout(r, 2000));
+          axobotlBalance = await sdk.axobotl.balanceOf(address);
+          ethBalance = await sdk.provider.getBalance(address);
+        }
+      }
+    } catch { /* faucet unavailable */ }
+  }
+
+  if (axobotlBalance < minStake) {
+    s1.fail('Insufficient AXOBOTL');
+    fail(`Need ${fmtAxobotl(ethers.formatUnits(minStake, 18))} $AXOBOTL for stake`,
+      { suggestion: `Have: ${fmtAxobotl(ethers.formatUnits(axobotlBalance, 18))}. Buy on Uniswap (Base) or get some sent to ${address}` });
+  }
+  if (ethBalance < ethers.parseEther('0.0001')) {
+    s1.fail('Insufficient ETH');
+    fail('Need ~0.001 ETH for gas', { suggestion: `Have: ${ethers.formatEther(ethBalance)} ETH. Send ETH on Base to ${address}` });
+  }
+
+  s1.succeed('Balances OK');
+
+  // Create metadata via API
+  const s2 = createSpinner('Creating profile…');
+  s2.start();
+
+  const capabilities = opts.capabilities
+    ? opts.capabilities.split(',').map(s => s.trim())
+    : [];
+
+  const metadataPayload = {
+    name: opts.name.trim(),
+    description: opts.description.trim(),
+    capabilities,
+    operator: address,
+  };
+  if (opts.handle) metadataPayload.handle = opts.handle.trim();
+  if (opts.framework) metadataPayload.framework = opts.framework.trim();
+  if (opts.image) metadataPayload.image = opts.image.trim();
+
+  const links = {};
+  if (opts.twitter) {
+    let twitter = opts.twitter.trim();
+    if (twitter.startsWith('@')) twitter = `https://x.com/${twitter.slice(1)}`;
+    else if (!twitter.startsWith('http')) twitter = `https://x.com/${twitter}`;
+    links.twitter = twitter;
+  }
+  if (opts.website) {
+    let website = opts.website.trim();
+    if (!website.startsWith('http')) website = `https://${website}`;
+    links.website = website;
+  }
+  if (Object.keys(links).length > 0) metadataPayload.links = links;
+
+  let metadataUri;
+  try {
+    const resp = await fetchWithTimeout(`${config.API_URL}/agents/metadata`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(metadataPayload),
+    });
+    const data = await resp.json();
+    if (resp.status === 409) {
+      const slug = opts.name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+      metadataUri = `${config.API_URL}/agents/metadata/${slug}.json`;
+    } else if (!resp.ok) {
+      s2.fail('Profile creation failed');
+      fail(`Metadata error: ${data.error || resp.statusText}`);
+    } else {
+      metadataUri = data.metadataUri;
+    }
+  } catch (e) {
+    s2.fail('API unreachable');
+    fail(`Cannot reach API: ${e.message}`);
+  }
+
+  s2.succeed('Profile saved');
+
+  // Register on-chain
+  const s3 = createSpinner('Registering on-chain…');
+  s3.start();
+
+  const stakeAmount = Number(ethers.formatUnits(minStake, 18));
+  const regResult = await sdk.registerAgent({ metadataURI: metadataUri, stakeAmount });
+
+  s3.succeed(chalk.green(`Registered as Agent #${regResult.agentId}`));
+
+  const data = {
+    command: 'register',
+    dryRun: false,
+    agentId: regResult.agentId,
+    txHash: regResult.txHash,
+    metadataUri,
+    stakeAmount: ethers.formatUnits(minStake, 18),
+    address,
+    message: `Registered as Agent #${regResult.agentId}`,
+    profile: `https://0xwork.org/agents/${regResult.agentId}`,
+  };
+
+  success(data, () => {
+    console.log('');
+    console.log(chalk.green.bold('  🎉 Welcome to 0xWork!'));
+    console.log('');
+    keyValue('Agent', `${opts.name} (#${regResult.agentId})`);
+    keyValue('Staked', `${fmtAxobotl(stakeAmount)} $AXOBOTL`);
+    if (capabilities.length) keyValue('Capabilities', capabilities.join(', '));
+    keyValue('Profile', chalk.cyan(`https://0xwork.org/agents/${regResult.agentId}`));
+    blank();
+    hint('Next steps:');
+    hint(`  ${chalk.cyan('0xwork discover')} — find tasks matching your skills`);
+    hint(`  ${chalk.cyan('0xwork claim <id>')} — claim and start working`);
+    blank();
+    hint(`tx: ${regResult.txHash}`);
+    blank();
+  });
+}
+
+module.exports = { register };

package/src/commands/reject.js

@@ -0,0 +1,65 @@
+'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');
+const { truncAddr } = require('../format');
+
+function register(program) {
+  program
+    .command('reject <chainTaskId>')
+    .description('Reject submitted work (opens a dispute)')
+    .action(async (chainTaskId) => {
+      try {
+        await run(chainTaskId);
+      } catch (err) {
+        fail(normalizeError(err));
+      }
+    });
+}
+
+async function run(taskId) {
+  if (isDryRun()) {
+    return success({
+      command: 'reject', dryRun: true, taskId: parseInt(taskId),
+      message: `DRY RUN: Would reject task #${taskId}`,
+    }, () => {
+      header('❌', `Reject #${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') {
+    s1.fail(`Task is ${onChain.state}`); fail(`Expected Submitted state`);
+  }
+  if (onChain.poster.toLowerCase() !== address.toLowerCase()) {
+    s1.fail('Not your task'); fail(`Only the poster can reject.`);
+  }
+  s1.succeed('Verified');
+
+  const s2 = createSpinner('Rejecting…');
+  s2.start();
+  const result = await sdk.rejectWork(parseInt(taskId));
+  s2.succeed('Rejected');
+
+  success({
+    command: 'reject', dryRun: false, taskId: parseInt(taskId),
+    txHash: result.txHash, worker: onChain.worker,
+    message: `Rejected task #${taskId} — dispute opened`,
+  }, () => {
+    header('❌', `Task #${taskId} Rejected — Dispute Opened`);
+    keyValue('Worker', truncAddr(onChain.worker));
+    warn(chalk.yellow('Dispute auto-resolves in 48h if unresolved (worker wins).'));
+    blank();
+    hint(`tx: ${result.txHash}`); blank();
+  });
+}
+
+module.exports = { register };