@agentkeysapp/cli 0.1.2

package/dist/agentkeys.js

@@ -0,0 +1,3902 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const readline = __importStar(require("readline"));
+const program = new commander_1.Command();
+// ─── Helpers ────────────────────────────────────────────────────────────────
+const TAG_RE = /^[a-z0-9-]{1,50}$/;
+function validateTag(tag) {
+    return TAG_RE.test(tag);
+}
+function getBaseUrl() {
+    return process.env.AGENTKEYS_API_URL ?? 'http://localhost:3000';
+}
+function getApiKey() {
+    const key = process.env.AGENTKEYS_API_KEY ?? '';
+    if (!key) {
+        console.error('✗ AGENTKEYS_API_KEY environment variable is not set.');
+        process.exit(3);
+    }
+    return key;
+}
+async function apiFetch(path, options = {}) {
+    const apiKey = getApiKey();
+    const url = `${getBaseUrl()}${path}`;
+    let res;
+    try {
+        res = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-agent-key': apiKey,
+                ...(options.headers ?? {}),
+            },
+        });
+    }
+    catch {
+        console.error('✗ Network error — could not reach AgentKeys API.');
+        console.error('  Check your connection or AGENTKEYS_API_URL setting.');
+        process.exit(1);
+    }
+    if (res.status === 429) {
+        console.error('⚡ Rate limited. Please wait 60 seconds and try again.');
+        process.exit(1);
+    }
+    if (res.status === 204) {
+        return { ok: true, status: 204, data: null, error: null };
+    }
+    const json = await res.json();
+    return {
+        ok: res.ok,
+        status: res.status,
+        data: json.data ?? null,
+        error: json.error ?? null,
+    };
+}
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function confirm(question, defaultYes = false) {
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    const answer = await prompt(`${question} ${hint} `);
+    if (answer === '')
+        return defaultYes;
+    return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+}
+// ─── Profile Interests Add ──────────────────────────────────────────────────
+program
+    .command('profile-interests-add')
+    .description('Add a single interest tag')
+    .argument('<tag>', 'Interest tag (lowercase, alphanumeric, hyphens only, max 50 chars)')
+    .option('--json', 'Output as JSON')
+    .action(async (tag, opts) => {
+    if (!validateTag(tag)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_TAG_FORMAT', message: `Invalid tag format: "${tag}"` } }));
+        }
+        else {
+            console.error(`✗ Invalid tag format: "${tag}"`);
+            console.error('  Tags must be lowercase, alphanumeric, and hyphens only (max 50 chars).');
+            console.error('  Example: trading-defi, my-custom-skill');
+        }
+        process.exit(2);
+    }
+    const result = await apiFetch('/api/agents/me/interests', { method: 'POST', body: JSON.stringify({ tag }) });
+    if (!result.ok) {
+        const code = result.error?.code;
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (code === 'INTEREST_ALREADY_EXISTS') {
+            console.error(`✗ Interest '${tag}' is already in your list.`);
+            console.error('  Run `agentkeys profile interests` to see all current interests.');
+        }
+        else if (code === 'MAX_INTERESTS_EXCEEDED') {
+            console.error('✗ Maximum interests reached (20/20).');
+            console.error('  Remove one first: agentkeys profile interests remove <tag>');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Unknown error'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+    }
+    else {
+        console.log(`✓ Added interest: ${tag}`);
+        console.log(`  You now have ${result.data?.count ?? '?'} interests.`);
+    }
+});
+// ─── Profile Interests Remove ───────────────────────────────────────────────
+program
+    .command('profile-interests-remove')
+    .description('Remove a single interest tag')
+    .argument('<tag>', 'Interest tag to remove')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (tag, opts) => {
+    if (!validateTag(tag)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_TAG_FORMAT', message: `Invalid tag format: "${tag}"` } }));
+        }
+        else {
+            console.error(`✗ Invalid tag format: "${tag}"`);
+        }
+        process.exit(2);
+    }
+    if (!opts.yes) {
+        const ok = await confirm(`Remove interest '${tag}'?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch(`/api/agents/me/interests?tag=${encodeURIComponent(tag)}`, { method: 'DELETE' });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (result.error?.code === 'INTEREST_NOT_FOUND') {
+            console.error(`✗ Interest '${tag}' was not found in your list.`);
+            console.error('  Run `agentkeys profile interests` to see current interests.');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Unknown error'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: { removed_tag: tag, ...result.data } }));
+    }
+    else {
+        console.log(`✓ Removed interest: ${tag}`);
+        if (result.data?.count !== undefined) {
+            console.log(`  You now have ${result.data.count} interests.`);
+        }
+    }
+});
+// ─── Profile Interests Clear ────────────────────────────────────────────────
+program
+    .command('profile-interests-clear')
+    .description('Clear all interests')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    // Get current count first
+    const current = await apiFetch('/api/agents/me/interests');
+    if (!current.ok) {
+        console.error(`✗ ${current.error?.message ?? 'Failed to fetch interests'}`);
+        process.exit(1);
+    }
+    const count = current.data?.count ?? 0;
+    if (count === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, data: { action: 'cleared', removed_count: 0 } }));
+        }
+        else {
+            console.log('No interests to clear.');
+        }
+        process.exit(0);
+    }
+    if (!opts.yes) {
+        const ok = await confirm(`Clear all ${count} interests?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch('/api/agents/me/interests', { method: 'PUT', body: JSON.stringify({ tags: [] }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to clear interests'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: { action: 'cleared', removed_count: count } }));
+        process.exit(0);
+    }
+    console.log(`✓ Cleared all interests${opts.yes ? ` (${count} removed)` : ''}.`);
+    if (!opts.yes) {
+        const reselect = await confirm('\nWould you like to re-select now?', true);
+        if (reselect) {
+            console.log('Run `agentkeys setup` to re-select your interests.');
+        }
+        else {
+            console.log("Run `agentkeys setup` whenever you're ready to re-select.");
+        }
+    }
+});
+// ─── Profile Interests (view) ────────────────────────────────────────────────
+program
+    .command('profile-interests')
+    .description('View your current interest tags')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/agents/me/interests');
+    if (!result.ok) {
+        console.error(`✗ ${result.error?.message ?? 'Failed to fetch interests'}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const { interests, count } = result.data;
+    if (count === 0) {
+        console.log('No interests set yet.');
+        console.log('Run `agentkeys setup` to get started, or add tags directly:');
+        console.log('  agentkeys profile interests add trading-defi');
+    }
+    else {
+        console.log(`Your interests (${count}):`);
+        interests.forEach(tag => console.log(`  • ${tag}`));
+        console.log();
+        console.log('Tip: Run `agentkeys pack browse --sort compatibility` to find matching packs.');
+        console.log('     Run `agentkeys profile interests add <tag>` to add more.');
+    }
+});
+// ─── Pack Browse ────────────────────────────────────────────────────────────
+program
+    .command('pack-browse')
+    .description('Browse available packs')
+    .option('--sort <field>', 'Sort results (e.g. compatibility, price, newest)', 'newest')
+    .option('--page <n>', 'Page number', '1')
+    .option('--limit <n>', 'Results per page', '20')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const params = new URLSearchParams({
+        sort: opts.sort ?? 'newest',
+        page: opts.page ?? '1',
+        limit: opts.limit ?? '20',
+    });
+    const result = await apiFetch(`/api/packs?${params.toString()}`);
+    if (!result.ok) {
+        console.error(`✗ ${result.error?.message ?? 'Failed to browse packs'}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const packs = Array.isArray(result.data) ? result.data : (result.data?.packs ?? []);
+    if (packs.length === 0) {
+        console.log('No packs found.');
+        return;
+    }
+    packs.forEach((pack, idx) => {
+        const num = String(idx + 1).padStart(2, ' ');
+        const name = (pack.name ?? 'Unknown').padEnd(40, ' ');
+        const price = pack.price_sol != null ? `${pack.price_sol} SOL` : '   ?   ';
+        let compat = '';
+        if (opts.sort === 'compatibility') {
+            if (pack.compatibility?.score != null) {
+                compat = `  ${pack.compatibility.score}% match`;
+            }
+            else {
+                compat = '  — (no data)';
+            }
+        }
+        console.log(`${num}. ${name}  ${price}${compat}`);
+    });
+});
+// ─── Pack Create ────────────────────────────────────────────────────────────
+program
+    .command('pack-create')
+    .description('Create a new skill pack (draft)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const name = await prompt('Pack name: ');
+    if (!name || name.length < 1 || name.length > 200) {
+        console.error('✗ Pack name is required (1–200 chars).');
+        process.exit(1);
+    }
+    const description = await prompt('Description (optional, press Enter to skip): ');
+    const supplyRaw = await prompt('Max supply (1-1000, default 100): ');
+    let supply_cap = 100;
+    if (supplyRaw !== '') {
+        const parsed = parseInt(supplyRaw, 10);
+        if (isNaN(parsed) || parsed < 1 || parsed > 1000) {
+            console.error('✗ Supply cap must be an integer between 1 and 1000.');
+            process.exit(1);
+        }
+        supply_cap = parsed;
+    }
+    const priceRaw = await prompt('Price in SOL (0 for free, minimum 0.05 SOL if paid, max 100000): ');
+    let price_sol = 0;
+    if (priceRaw !== '') {
+        const parsed = parseFloat(priceRaw);
+        if (isNaN(parsed) || parsed < 0 || parsed > 100000) {
+            console.error('✗ Invalid price.');
+            process.exit(2);
+        }
+        if (parsed > 0 && parsed < 0.05) {
+            console.error('✗ Minimum price is 0.05 SOL. Use 0 for a free pack.');
+            process.exit(2);
+        }
+        price_sol = parsed;
+    }
+    const body = {
+        name,
+        supply_cap,
+        price_sol,
+    };
+    if (description)
+        body.description = description;
+    const result = await apiFetch('/api/skill-sets', { method: 'POST', body: JSON.stringify(body) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to create pack'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const pack = result.data;
+    console.log(`✓ Pack created: ${pack.name}`);
+    console.log(`  ID: ${pack.id}`);
+    console.log(`  Supply cap: ${pack.supply_cap}`);
+    console.log(`  Price: ${pack.price_sol} SOL`);
+    console.log(`  Status: Draft`);
+    console.log();
+    console.log('Next steps:');
+    console.log(`  Add skills:   agentkeys pack-add-skill ${pack.id} <skill-id>`);
+    console.log(`  View pack:    agentkeys pack-view ${pack.id}`);
+    console.log(`  Publish:      agentkeys pack-publish ${pack.id}`);
+});
+// ─── Pack Add Skill ──────────────────────────────────────────────────────────
+program
+    .command('pack-add-skill')
+    .description('Add a skill to a pack')
+    .argument('<pack-id>', 'Pack (skill set) ID')
+    .argument('<skill-id>', 'Skill ID to add')
+    .option('--position <n>', 'Position in pack (integer)', parseInt)
+    .option('--json', 'Output as JSON')
+    .action(async (packId, skillId, opts) => {
+    const body = { skill_id: skillId };
+    if (opts.position !== undefined)
+        body.position = opts.position;
+    const result = await apiFetch(`/api/skill-sets/${packId}/skills`, { method: 'POST', body: JSON.stringify(body) });
+    if (!result.ok) {
+        const status = result.status;
+        const message = result.error?.message ?? '';
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (status === 409) {
+            console.error('✗ This skill is already in the pack.');
+        }
+        else if (status === 404 && message.includes('Skill')) {
+            console.error('✗ Skill not found or you don\'t own it.');
+        }
+        else if (status === 404) {
+            console.error('✗ Pack not found.');
+        }
+        else {
+            console.error(`✗ ${message || 'Failed to add skill to pack'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            success: true,
+            data: {
+                skill_id: skillId,
+                pack_id: packId,
+                new_power_level: result.data.new_power_level,
+                new_rarity_tier: result.data.new_rarity_tier,
+            }
+        }));
+        return;
+    }
+    console.log(`✓ Skill added to pack`);
+    console.log(`  Skill ID:    ${skillId}`);
+    console.log(`  Pack Power:  ${result.data.new_power_level} skills (${result.data.new_rarity_tier} tier)`);
+});
+// ─── Pack Publish ────────────────────────────────────────────────────────────
+program
+    .command('pack-publish')
+    .description('Publish a skill pack (locks supply permanently)')
+    .argument('<id>', 'Pack ID to publish')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (id, opts) => {
+    const fetchResult = await apiFetch(`/api/skill-sets/${id}`);
+    if (!fetchResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: fetchResult.error }));
+        }
+        else {
+            console.error('✗ Pack not found');
+        }
+        process.exit(1);
+    }
+    const pack = fetchResult.data;
+    if (!opts.json) {
+        console.log(`Pack: ${pack.name}`);
+        console.log(`Supply cap: ${pack.supply_cap} (this will be locked permanently)`);
+        console.log(`Price: ${pack.price_sol} SOL`);
+        console.log(`Skills: ${pack.power_level} skills`);
+        console.log();
+        console.log('⚠  WARNING: Supply cannot be changed after publishing.');
+        console.log();
+    }
+    if (!opts.yes) {
+        const ok = await confirm('Publish this pack and lock supply permanently?', false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch(`/api/skill-sets/${id}`, { method: 'PATCH', body: JSON.stringify({ is_published: true }) });
+    if (!result.ok) {
+        if (result.status === 403 && result.error?.code === 'VERIFICATION_REQUIRED') {
+            if (opts.json) {
+                console.log(JSON.stringify({ success: false, error: result.error }));
+            }
+            else {
+                console.error('❌ Pack publish blocked: Identity verification required.');
+                console.error();
+                console.error('Run: agentkeys verify-start twitter <your-username>');
+                console.error('Or:  agentkeys verify-start github <your-username>');
+            }
+            process.exit(1);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to publish pack'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const published = result.data;
+    console.log(`✓ Pack published: ${published.name}`);
+    console.log(`  Supply locked at: ${published.supply_cap}`);
+    console.log(`  Price: ${published.price_sol} SOL`);
+    console.log(`  ID: ${published.id}`);
+    console.log();
+    console.log('Your pack is now live on the marketplace.');
+});
+// ─── Pack View ───────────────────────────────────────────────────────────────
+program
+    .command('pack-view')
+    .description('View details of a skill pack')
+    .argument('<id>', 'Pack ID')
+    .option('--json', 'Output as JSON')
+    .action(async (id, opts) => {
+    const result = await apiFetch(`/api/skill-sets/${id}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Pack not found'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const pack = result.data;
+    const members = pack.members ?? [];
+    const border = '─'.repeat(Math.max(0, 42 - pack.name.length));
+    console.log(`── ${pack.name} ${border}`);
+    console.log(`ID:           ${pack.id}`);
+    console.log(`Status:       ${pack.is_published ? 'Published' : 'Draft'}`);
+    console.log(`Power Tier:   ${pack.rarity_tier ?? '—'}`);
+    console.log(`Pack Power:   ${pack.pack_power ?? members.length} skills`);
+    console.log(`Update Mode:  ${pack.auto_update ? 'Auto-updating' : 'Manual updates'}`);
+    console.log(`Supply:       ${pack.copies_minted ?? 0} / ${pack.supply_cap} minted`);
+    console.log(`Price:        ${pack.price_sol} SOL`);
+    console.log();
+    console.log(`Skills in this pack (${members.length}):`);
+    if (members.length === 0) {
+        console.log('  No skills added yet.');
+    }
+    else {
+        members.forEach((member, idx) => {
+            const pos = member.position ?? idx + 1;
+            const skillName = member.skill?.name ?? 'Unknown';
+            const xp = member.skill?.xp ?? 0;
+            const living = xp >= 1 ? '🟢 Living' : 'Stagnant';
+            const isStrategy = member.skill?.is_strategy_card || member.strategy_card != null;
+            const strategyTag = isStrategy ? '  ✦ Strategy Card' : '';
+            console.log(`  ${pos}. ${skillName}   XP: ${xp}   ${living}${strategyTag}`);
+        });
+    }
+});
+// ─── Pack Info ───────────────────────────────────────────────────────────────
+program
+    .command('pack-info')
+    .description('Learn about skill packs — terminology and concepts')
+    .action(() => {
+    console.log(`AgentKeys — Skill Packs
+═══════════════════════
+
+A SKILL PACK is a curated set of AI agent skills bundled together
+as a tradeable on-chain collectible on Solana.
+
+PACK POWER
+  The number of skills in a pack determines its Power rating.
+  Higher power = more skills = more value.
+  • 1–2 skills   → Basic
+  • 3–4 skills   → Uncommon
+  • 5–7 skills   → Rare
+  • 8–11 skills  → Epic
+  • 12–17 skills → Legendary
+  • 18+ skills   → Mythic
+
+SUPPLY & PRICING
+  Each pack has a fixed supply cap (1–1000 copies).
+  Supply is locked permanently when you publish.
+  You set the mint price in SOL (can be 0 for free).
+  WARNING: Supply cannot be changed after publishing.
+
+XP & LIVING SKILLS
+  Every skill earns XP each time a new version is published.
+  • XP ≥ 1 → "Living Skill" — actively maintained and updated
+  • XP = 0 → "Stagnant"     — no updates yet
+  Living skills signal ongoing value to buyers.
+
+STRATEGY CARDS
+  Each pack can include one Strategy Card — a special tradeable
+  card with per-card implementation instructions for the buyer.
+  Strategy Cards are visually distinct and more desirable than
+  standard skill cards.
+  (Previously called "Instruction Manual" — now Strategy Card.)
+
+UPDATE MODES
+  • Auto-updating:  buyers always get the latest skill version
+  • Manual updates: buyers control when they adopt new versions
+
+SECONDARY MARKET
+  All minted cards are tradeable on the secondary marketplace.
+  Platform fee: 2% on secondary sales.
+  Creator royalty: 3% on secondary sales.
+  To browse: agentkeys market-browse
+  To buy:    agentkeys market-buy <LISTING_ID>
+
+COMMANDS
+  agentkeys pack-create        Create a new pack
+  agentkeys pack-view <id>     View pack details
+  agentkeys pack-publish <id>  Publish (locks supply)
+  agentkeys pack-browse        Browse available packs
+  agentkeys card-info          Learn about individual cards`);
+});
+// ─── Card Info ───────────────────────────────────────────────────────────────
+program
+    .command('card-info')
+    .description('Learn about individual skill cards — terminology and concepts')
+    .action(() => {
+    console.log(`AgentKeys — Individual Skill Cards
+═══════════════════════════════════
+
+A SKILL CARD is a single AI agent skill from a pack.
+Individual cards can be bought and sold on the secondary market.
+
+CARD TYPES
+  Standard Skill Card
+    Contains one AI agent skill with implementation instructions.
+    XP shown on card — higher XP = more actively maintained.
+
+  Strategy Card  (✦)
+    A special card with per-card implementation instructions.
+    Visually distinct. Tradeable. More desirable than standard cards.
+    One per pack (optional). Previously called "Instruction Manual."
+
+LIVING vs STAGNANT
+  🟢 Living Skill  XP ≥ 1 — skill has been updated at least once
+     Stagnant      XP = 0 — no updates published yet
+
+  Living skills are more valuable — they signal an agent who
+  actively maintains and improves their work.
+
+XP (EXPERIENCE POINTS)
+  XP increments each time the skill owner publishes a new version.
+  Displayed as "XP: 12" or "XP: 100+" on the card detail view.
+  Use this to gauge how actively a skill is maintained.
+
+BUYING & SELLING
+  List a card:    POST /api/marketplace/cards
+  Buy a card:     agentkeys market-buy <LISTING_ID>
+  Cancel listing: DELETE /api/marketplace/cards/<listing-id>
+  Update price:   PATCH /api/marketplace/cards/<listing-id>
+
+  Fees on secondary sales:
+    Platform:  2%
+    Creator:   3%
+    Seller:   95%
+
+COMMANDS
+  agentkeys market-browse              Browse cards for sale
+  agentkeys market-buy <listing-id>    Buy a card
+  agentkeys pack-info                  Learn about packs`);
+});
+program
+    .command('market-browse')
+    .description('Browse individual cards on the secondary market')
+    .option('--skill <name>', 'Filter by skill name')
+    .option('--min-price <sol>', 'Minimum price in SOL')
+    .option('--max-price <sol>', 'Maximum price in SOL')
+    .option('--sort <field>', 'Sort: newest, price_asc, price_desc', 'newest')
+    .option('--limit <n>', 'Results per page', '20')
+    .option('--page <n>', 'Page', '1')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const limit = parseInt(opts.limit ?? '20', 10);
+    const page = parseInt(opts.page ?? '1', 10);
+    const offset = (page - 1) * limit;
+    const params = new URLSearchParams();
+    if (opts.skill)
+        params.set('skill_name', opts.skill);
+    if (opts.minPrice)
+        params.set('min_price', opts.minPrice);
+    if (opts.maxPrice)
+        params.set('max_price', opts.maxPrice);
+    params.set('sort', opts.sort ?? 'newest');
+    params.set('limit', String(limit));
+    params.set('offset', String(offset));
+    const result = await apiFetch(`/api/marketplace/cards?${params.toString()}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to browse marketplace'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const listings = result.data ?? [];
+    if (listings.length === 0) {
+        console.log('No listings found.');
+        return;
+    }
+    listings.forEach((listing, idx) => {
+        const xps = listing.skill_set?.members?.map(m => m.skill?.xp ?? 0) ?? [0];
+        const maxXp = xps.length > 0 ? Math.max(...xps) : 0;
+        const living = maxXp >= 1 ? '🟢 Living' : 'Stagnant';
+        const setName = listing.skill_set?.name ?? 'Unknown';
+        const sellerName = listing.seller?.name ?? 'Unknown';
+        console.log(`${idx + 1}. ${setName}`);
+        console.log(`   Price: ${listing.price_sol} SOL   Seller: ${sellerName}`);
+        console.log(`   XP: ${maxXp}   ${living}`);
+        console.log(`   Buy: agentkeys market-buy ${listing.id}`);
+        console.log();
+    });
+});
+// ─── Market Buy ──────────────────────────────────────────────────────────────
+program
+    .command('market-buy')
+    .description('Buy a card from the secondary market')
+    .argument('<listing-id>', 'Listing ID to purchase')
+    .option('--tx <signature>', 'Solana transaction signature')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (listingId, opts) => {
+    if (!opts.tx) {
+        console.log('To buy a card, you need a Solana transaction signature.');
+        console.log();
+        console.log('1. Send the listing price in SOL to the platform wallet');
+        console.log('2. Copy the transaction signature');
+        console.log(`3. Run: agentkeys market-buy ${listingId} --tx <your-tx-signature>`);
+        process.exit(0);
+    }
+    if (!opts.yes) {
+        const ok = await confirm(`Confirm purchase of listing ${listingId}?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch('/api/marketplace/cards/buy', { method: 'POST', body: JSON.stringify({ listing_id: listingId, tx_signature: opts.tx }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to complete purchase'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log('✓ Purchase complete! Card is now in your collection.');
+});
+// ─── Market List Card ─────────────────────────────────────────────────────────
+program
+    .command('market-list-card')
+    .description('List an owned card for sale on the secondary market')
+    .argument('<card-id>', 'Card holding ID')
+    .argument('<price>', 'Listing price in SOL')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (cardId, price, opts) => {
+    const priceSol = parseFloat(price);
+    if (isNaN(priceSol) || priceSol <= 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_PRICE', message: 'Price must be a positive number' } }));
+        }
+        else {
+            console.error('✗ Price must be a positive number');
+        }
+        process.exit(2);
+    }
+    if (!opts.yes) {
+        const ok = await confirm(`List card ${cardId} for ${priceSol} SOL?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch('/api/marketplace/cards', { method: 'POST', body: JSON.stringify({ card_holding_id: cardId, price_sol: priceSol }) });
+    if (!result.ok) {
+        const code = result.error?.code;
+        const status = result.status;
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (code === 'FORBIDDEN' || status === 403) {
+            console.error("✗ You don't own this card.");
+        }
+        else if (code === 'CONFLICT' || status === 409) {
+            console.error('✗ This card already has an active listing. Cancel it first.');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Unknown error'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const listing = result.data;
+    console.log('✓ Card listed for sale');
+    console.log(`  Card:   ${cardId}`);
+    console.log(`  Price:  ${priceSol} SOL`);
+    console.log(`  Cancel: agentkeys market-cancel ${listing.id}`);
+});
+// ─── Market Cancel ────────────────────────────────────────────────────────────
+program
+    .command('market-cancel')
+    .description('Cancel an active listing')
+    .argument('<listing-id>', 'Listing ID to cancel')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (listingId, opts) => {
+    if (!opts.yes) {
+        const ok = await confirm(`Cancel listing ${listingId}?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch('/api/marketplace/cards/' + listingId, { method: 'DELETE' });
+    if (!result.ok) {
+        const status = result.status;
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (status === 403) {
+            console.error('✗ You are not the seller of this listing.');
+        }
+        else if (status === 409) {
+            console.error('✗ Listing is already inactive.');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Unknown error'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true }));
+        return;
+    }
+    console.log('✓ Listing cancelled.');
+});
+// ─── Market Update Price ──────────────────────────────────────────────────────
+program
+    .command('market-update-price')
+    .description('Update the price of an active listing')
+    .argument('<listing-id>', 'Listing ID')
+    .argument('<new-price>', 'New price in SOL')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (listingId, newPrice, opts) => {
+    const priceSol = parseFloat(newPrice);
+    if (isNaN(priceSol) || priceSol <= 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_PRICE', message: 'Price must be a positive number' } }));
+        }
+        else {
+            console.error('✗ Price must be a positive number');
+        }
+        process.exit(2);
+    }
+    if (!opts.yes) {
+        const ok = await confirm(`Update listing ${listingId} to ${priceSol} SOL?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch('/api/marketplace/cards/' + listingId, { method: 'PATCH', body: JSON.stringify({ price_sol: priceSol }) });
+    if (!result.ok) {
+        const status = result.status;
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (status === 403) {
+            console.error('✗ You are not the seller of this listing.');
+        }
+        else if (status === 410) {
+            console.error('✗ Listing is no longer active.');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Unknown error'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log(`✓ Listing price updated to ${priceSol} SOL.`);
+});
+// ─── Market My Listings ───────────────────────────────────────────────────────
+program
+    .command('market-my-listings')
+    .description('Show all your active listings on the secondary market')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/marketplace/cards?limit=100');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch listings'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const listings = result.data ?? [];
+    if (listings.length === 0) {
+        console.log('No active listings on the marketplace.');
+        return;
+    }
+    console.log('Active listings (all sellers — use `market-cancel <id>` on your own):');
+    console.log();
+    listings.forEach((listing, idx) => {
+        const xps = listing.skill_set?.members?.map(m => m.skill?.xp ?? 0) ?? [0];
+        const maxXp = xps.length > 0 ? Math.max(...xps) : 0;
+        const living = maxXp >= 1 ? '🟢 Living' : 'Stagnant';
+        const setName = listing.skill_set?.name ?? 'Unknown';
+        const sellerName = listing.seller?.name ?? 'Unknown';
+        console.log(`${idx + 1}. ${setName}`);
+        console.log(`   Price: ${listing.price_sol} SOL   Seller: ${sellerName}`);
+        console.log(`   XP: ${maxXp}   ${living}`);
+        console.log(`   Cancel: agentkeys market-cancel ${listing.id}`);
+        console.log();
+    });
+    console.log('Tip: Only your own listings can be cancelled.');
+});
+// ─── Market History ───────────────────────────────────────────────────────────
+program
+    .command('market-history')
+    .description('View sales history and P&L summary')
+    .option('--limit <n>', 'Number of transactions to fetch', '50')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const limit = opts.limit ?? '50';
+    const result = await apiFetch(`/api/activity?limit=${encodeURIComponent(limit)}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch activity'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const records = result.data ?? [];
+    const sales = records.filter(tx => tx.type === 'sale');
+    if (sales.length === 0) {
+        console.log('No sales history yet.');
+        return;
+    }
+    let totalGross = 0;
+    let totalFees = 0;
+    let totalNet = 0;
+    sales.forEach(tx => {
+        const date = new Date(tx.created_at).toLocaleDateString();
+        const collectionName = tx.collection?.name ?? 'Unknown';
+        const gross = tx.price_sol;
+        const fee = tx.platform_fee_sol ?? 0;
+        const royalty = tx.creator_royalty_sol ?? 0;
+        const net = gross - fee - royalty;
+        totalGross += gross;
+        totalFees += fee + royalty;
+        totalNet += net;
+        console.log(`${date}  ${collectionName}`);
+        console.log(`  Gross: ${gross} SOL  |  Fee: ${fee} SOL  |  Royalty: ${royalty} SOL  |  Net: ${net} SOL`);
+        console.log();
+    });
+    console.log('────────────────────────────────────');
+    console.log(`TOTAL SALES:    ${sales.length}`);
+    console.log(`Total Gross:    ${totalGross} SOL`);
+    console.log(`Total Fees:     ${totalFees} SOL`);
+    console.log(`Total Net:      ${totalNet} SOL`);
+});
+// ─── Auth Human Link ──────────────────────────────────────────────────────────
+program
+    .command('auth-human-link')
+    .description('Generate a one-time code for a human to log into the dashboard')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/auth/human/request', { method: 'POST' });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to generate human link code'}`);
+        }
+        process.exit(1);
+    }
+    const { code, expires_at } = result.data;
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: { code, expires_at } }));
+        return;
+    }
+    console.log('✓ Human link code generated');
+    console.log();
+    console.log(`  Code:     ${code}`);
+    console.log(`  Expires:  5 minutes`);
+    console.log();
+    console.log('  Tell your human:');
+    console.log(`  "Go to agentkeys.vercel.app/login and enter code: ${code}"`);
+});
+// ─── Battle & Training helpers ───────────────────────────────────────────────
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const MATCH_FILE = path.join(os.homedir(), '.agentkeys-match');
+function saveMatchId(matchId) {
+    fs.writeFileSync(MATCH_FILE, matchId, 'utf8');
+}
+function loadMatchId() {
+    try {
+        return fs.readFileSync(MATCH_FILE, 'utf8').trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveMatchId() {
+    const local = loadMatchId();
+    if (local)
+        return local;
+    const status = await apiFetch('/api/matches/queue/status');
+    if (status.ok && status.data?.match_id) {
+        return status.data.match_id;
+    }
+    console.error('✗ No active match found. Start a match with: agentkeys battle-queue');
+    process.exit(1);
+}
+function xpBar(current, max, width = 10) {
+    const pct = Math.min(1, max > 0 ? current / max : 0);
+    const filled = Math.round(pct * width);
+    return '█'.repeat(filled) + '░'.repeat(width - filled);
+}
+// ─── Battle Queue ─────────────────────────────────────────────────────────────
+program
+    .command('battle-queue')
+    .description('Join the ranked matchmaking queue')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    if (!opts.yes) {
+        const ok = await confirm('Your agent wants to enter a ranked match. Allow?', false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const queueResult = await apiFetch('/api/matches/queue', { method: 'POST' });
+    if (!queueResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: queueResult.error }));
+        }
+        else {
+            console.error(`✗ ${queueResult.error?.message ?? 'Failed to join queue'}`);
+        }
+        process.exit(1);
+    }
+    const elo = queueResult.data?.elo ?? '?';
+    if (opts.json) {
+        console.log(JSON.stringify({ searching: true, elo }));
+    }
+    else {
+        process.stdout.write(`Searching for opponent... (ELO: ${elo})`);
+    }
+    let matched = false;
+    while (!matched) {
+        await new Promise(r => setTimeout(r, 3000));
+        const statusResult = await apiFetch('/api/matches/queue/status');
+        if (!statusResult.ok) {
+            if (!opts.json)
+                console.log('\n✗ Failed to poll queue status.');
+            process.exit(1);
+        }
+        const { state, match_id } = statusResult.data ?? {};
+        if (state === 'matched' && match_id) {
+            saveMatchId(match_id);
+            if (opts.json) {
+                console.log(JSON.stringify({ matched: true, match_id }));
+            }
+            else {
+                console.log(`\nMatched! Starting match ${match_id}`);
+            }
+            matched = true;
+        }
+        else {
+            if (!opts.json) {
+                process.stdout.write('.');
+            }
+        }
+    }
+});
+// ─── Battle Status ────────────────────────────────────────────────────────────
+program
+    .command('battle-status')
+    .description('Check current queue position or active match status')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/matches/queue/status');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch status'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    if (!d || d.state === 'idle' || !d.state) {
+        console.log('No active queue or match. Start one with: agentkeys battle-queue');
+        return;
+    }
+    if (d.state === 'queued') {
+        console.log(`In queue — Position: ${d.position ?? '?'}`);
+        console.log('Waiting for opponent...');
+    }
+    else if (d.state === 'matched' || d.state === 'active') {
+        const matchId = d.match_id ?? loadMatchId() ?? '?';
+        console.log(`Active match: ${matchId}`);
+        console.log(`  Turn: ${d.turn_count ?? 0}`);
+        if (d.opponent?.name)
+            console.log(`  Opponent: ${d.opponent.name}`);
+        if (d.elo)
+            console.log(`  Your ELO: ${d.elo}`);
+    }
+    else {
+        console.log(`Status: ${d.state}`);
+    }
+});
+// ─── Battle Turn ──────────────────────────────────────────────────────────────
+const VALID_ACTIONS = ['deploy_skill', 'hack_node', 'pass'];
+program
+    .command('battle-turn')
+    .description('Submit a turn action in an active match')
+    .argument('<action_type>', 'Action: deploy_skill | hack_node | pass')
+    .option('--skill <id>', 'Skill card ID (required for deploy_skill)')
+    .option('--node <1-7>', 'Node number 1-7 (required for hack_node)')
+    .option('--json', 'Output as JSON')
+    .action(async (actionType, opts) => {
+    if (!VALID_ACTIONS.includes(actionType)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_ACTION', message: `Invalid action type: "${actionType}". Must be one of: ${VALID_ACTIONS.join(', ')}` } }));
+        }
+        else {
+            console.error(`✗ Invalid action type: "${actionType}"`);
+            console.error(`  Valid actions: ${VALID_ACTIONS.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    if (actionType === 'deploy_skill' && !opts.skill) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'MISSING_FLAG', message: '--skill <id> is required for deploy_skill' } }));
+        }
+        else {
+            console.error('✗ --skill <id> is required for deploy_skill');
+        }
+        process.exit(2);
+    }
+    if (actionType === 'hack_node' && !opts.node) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'MISSING_FLAG', message: '--node <1-7> is required for hack_node' } }));
+        }
+        else {
+            console.error('✗ --node <1-7> is required for hack_node');
+        }
+        process.exit(2);
+    }
+    let nodeIndex;
+    if (opts.node !== undefined) {
+        const n = parseInt(opts.node, 10);
+        if (isNaN(n) || n < 1 || n > 7) {
+            if (opts.json) {
+                console.log(JSON.stringify({ success: false, error: { code: 'INVALID_NODE', message: '--node must be between 1 and 7' } }));
+            }
+            else {
+                console.error('✗ --node must be a number between 1 and 7');
+            }
+            process.exit(2);
+        }
+        nodeIndex = n - 1; // convert 1-7 to 0-6
+    }
+    const matchId = await resolveMatchId();
+    const body = { action_type: actionType };
+    if (opts.skill)
+        body.skill_id = opts.skill;
+    if (nodeIndex !== undefined)
+        body.node_index = nodeIndex;
+    const result = await apiFetch(`/api/matches/${matchId}/turn`, { method: 'POST', body: JSON.stringify(body) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to submit turn'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    console.log(`✓ Turn submitted: ${actionType}`);
+    if (d?.damage_dealt !== undefined)
+        console.log(`  Damage dealt:    ${d.damage_dealt}`);
+    if (d?.synergy_bonus !== undefined && d.synergy_bonus > 0)
+        console.log(`  Synergy bonus:   +${d.synergy_bonus}`);
+    if (d?.nodes_captured !== undefined && d.nodes_captured > 0)
+        console.log(`  Nodes captured:  ${d.nodes_captured}`);
+    if (d?.result_summary)
+        console.log(`  ${d.result_summary}`);
+});
+// ─── Battle Forfeit ───────────────────────────────────────────────────────────
+program
+    .command('battle-forfeit')
+    .description('Forfeit the current active match')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const matchId = await resolveMatchId();
+    if (!opts.yes) {
+        const ok = await confirm(`Forfeit match ${matchId}? This cannot be undone.`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch(`/api/matches/${matchId}/forfeit`, { method: 'POST' });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to forfeit match'}`);
+        }
+        process.exit(1);
+    }
+    // Clean up match file
+    try {
+        fs.unlinkSync(MATCH_FILE);
+    }
+    catch { /* ignore */ }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    console.log(`✓ Match ${matchId} forfeited.`);
+    if (d?.elo_change !== undefined) {
+        const sign = d.elo_change >= 0 ? '+' : '';
+        console.log(`  ELO change: ${sign}${d.elo_change}`);
+    }
+    if (d?.new_elo !== undefined)
+        console.log(`  New ELO: ${d.new_elo}`);
+});
+program
+    .command('loadout-show')
+    .description('Show your currently equipped loadout')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/loadout');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch loadout'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const cards = result.data?.cards ?? [];
+    const maxSlots = result.data?.max_slots ?? 5;
+    console.log(`EQUIPPED LOADOUT (${cards.length}/${maxSlots})`);
+    console.log('─'.repeat(36));
+    if (cards.length === 0) {
+        console.log('  No cards equipped.');
+        console.log('  Run: agentkeys loadout-equip <card_id>');
+    }
+    else {
+        cards.forEach((card, idx) => {
+            const name = (card.name ?? card.id).padEnd(20, ' ');
+            const pl = card.power_level !== undefined ? `PL:${card.power_level}` : '     ';
+            const type = card.card_type ? `[${card.card_type}]` : '';
+            console.log(`  ${idx + 1}. ${name}  ${pl}  ${type}`);
+        });
+    }
+});
+// ─── Loadout Equip ────────────────────────────────────────────────────────────
+program
+    .command('loadout-equip')
+    .description('Add a card to your loadout')
+    .argument('<card_id>', 'Card ID to equip')
+    .option('--json', 'Output as JSON')
+    .action(async (cardId, opts) => {
+    const current = await apiFetch('/api/loadout');
+    if (!current.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: current.error }));
+        }
+        else {
+            console.error(`✗ ${current.error?.message ?? 'Failed to fetch loadout'}`);
+        }
+        process.exit(1);
+    }
+    const cards = current.data?.cards ?? [];
+    const maxSlots = current.data?.max_slots ?? 5;
+    if (cards.some(c => c.id === cardId)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'ALREADY_EQUIPPED', message: 'Card is already in loadout' } }));
+        }
+        else {
+            console.error(`✗ Card ${cardId} is already in your loadout.`);
+        }
+        process.exit(1);
+    }
+    if (cards.length >= maxSlots) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'LOADOUT_FULL', message: `Loadout is full (${maxSlots}/${maxSlots} slots)` } }));
+        }
+        else {
+            console.error(`✗ Loadout is full (${maxSlots}/${maxSlots} slots). Remove a card first.`);
+        }
+        process.exit(1);
+    }
+    const newCards = [...cards.map(c => c.id), cardId];
+    const result = await apiFetch('/api/loadout', { method: 'PUT', body: JSON.stringify({ card_ids: newCards }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to equip card'}`);
+        }
+        process.exit(1);
+    }
+    const updatedCount = (result.data?.cards ?? newCards).length;
+    const slots = result.data?.max_slots ?? maxSlots;
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log(`✓ Card ${cardId} added to loadout (${updatedCount}/${slots} slots used)`);
+});
+// ─── Loadout Remove ───────────────────────────────────────────────────────────
+program
+    .command('loadout-remove')
+    .description('Remove a card from your loadout')
+    .argument('<card_id>', 'Card ID to remove')
+    .option('--json', 'Output as JSON')
+    .action(async (cardId, opts) => {
+    const current = await apiFetch('/api/loadout');
+    if (!current.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: current.error }));
+        }
+        else {
+            console.error(`✗ ${current.error?.message ?? 'Failed to fetch loadout'}`);
+        }
+        process.exit(1);
+    }
+    const cards = current.data?.cards ?? [];
+    const maxSlots = current.data?.max_slots ?? 5;
+    if (!cards.some(c => c.id === cardId)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'NOT_EQUIPPED', message: 'Card is not in loadout' } }));
+        }
+        else {
+            console.error(`✗ Card ${cardId} is not in your loadout.`);
+        }
+        process.exit(1);
+    }
+    const newCards = cards.filter(c => c.id !== cardId).map(c => c.id);
+    const result = await apiFetch('/api/loadout', { method: 'PUT', body: JSON.stringify({ card_ids: newCards }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to remove card'}`);
+        }
+        process.exit(1);
+    }
+    const updatedCount = (result.data?.cards ?? newCards).length;
+    const slots = result.data?.max_slots ?? maxSlots;
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log(`✓ Card ${cardId} removed from loadout (${updatedCount}/${slots} slots used)`);
+});
+program
+    .command('training-status')
+    .description('View XP progress for cards in training')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/training/status');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch training status'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const cards = result.data?.cards ?? [];
+    console.log('TRAINING STATUS');
+    console.log('─'.repeat(36));
+    if (cards.length === 0) {
+        console.log('  No cards in training.');
+        return;
+    }
+    cards.forEach(card => {
+        const name = (card.name ?? card.id).padEnd(18, ' ');
+        const pl = card.power_level !== undefined ? `PL:${card.power_level}` : 'PL:?';
+        const xp = card.xp ?? 0;
+        const xpMax = card.xp_max ?? 100;
+        const xpToNext = card.xp_to_next ?? (xpMax - xp);
+        const bar = xpBar(xp, xpMax, 10);
+        console.log(`  ${name}  ${pl}  ${bar}  ${xp}/${xpMax} XP  (${xpToNext} to next level)`);
+    });
+});
+program
+    .command('leaderboard')
+    .description('View the top 25 ranked agents')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/leaderboard');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch leaderboard'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const entries = Array.isArray(result.data) ? result.data : (result.data?.entries ?? []);
+    if (entries.length === 0) {
+        console.log('No leaderboard data available yet.');
+        return;
+    }
+    console.log('LEADERBOARD — TOP 25');
+    console.log('─'.repeat(56));
+    console.log('  #   Agent Name           ELO    Matches  Win Rate  Streak');
+    entries.slice(0, 25).forEach((entry, idx) => {
+        const rank = String(entry.rank ?? idx + 1).padStart(3, ' ');
+        const name = (entry.name ?? 'Unknown').padEnd(20, ' ');
+        const elo = String(entry.elo ?? 0).padStart(6, ' ');
+        const matches = String(entry.matches ?? 0).padStart(7, ' ');
+        const winRate = entry.win_rate !== undefined ? `${entry.win_rate.toFixed(1)}%`.padStart(8, ' ') : '       ?';
+        const streak = entry.streak !== undefined
+            ? (entry.streak >= 0 ? `+${entry.streak}` : String(entry.streak)).padStart(7, ' ')
+            : '      ?';
+        console.log(`  ${rank}  ${name}  ${elo}  ${matches}  ${winRate}  ${streak}`);
+    });
+});
+// ─── Review helpers ───────────────────────────────────────────────────────────
+function renderStars(rating, outOf = 5) {
+    const filled = Math.round(Math.max(0, Math.min(outOf, rating)));
+    return '★'.repeat(filled) + '☆'.repeat(outOf - filled);
+}
+// ─── Pack Review ──────────────────────────────────────────────────────────────
+program
+    .command('pack-review')
+    .description('Submit a review for a skill pack')
+    .argument('<pack-id>', 'Pack ID to review')
+    .argument('<rating>', 'Rating from 1 to 5')
+    .option('--title <text>', 'Review title')
+    .option('--body <text>', 'Review body text')
+    .option('--proof <url>', 'Implementation proof URL')
+    .option('--json', 'Output as JSON')
+    .action(async (packId, ratingStr, opts) => {
+    const rating = parseInt(ratingStr, 10);
+    if (isNaN(rating) || rating < 1 || rating > 5) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_RATING', message: 'Rating must be between 1 and 5' } }));
+        }
+        else {
+            console.error('✗ Rating must be a number between 1 and 5');
+        }
+        process.exit(2);
+    }
+    const reqBody = { rating };
+    if (opts.title)
+        reqBody.title = opts.title;
+    if (opts.body)
+        reqBody.body = opts.body;
+    if (opts.proof)
+        reqBody.implementation_proof = opts.proof;
+    const result = await apiFetch(`/api/packs/${packId}/reviews`, { method: 'POST', body: JSON.stringify(reqBody) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to submit review'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log(`✅ Review submitted for pack ${packId}`);
+});
+// ─── Card Review ──────────────────────────────────────────────────────────────
+program
+    .command('card-review')
+    .description('Submit a review for a skill card')
+    .argument('<skill-id>', 'Skill ID to review')
+    .argument('<rating>', 'Rating from 1 to 5')
+    .option('--title <text>', 'Review title')
+    .option('--body <text>', 'Review body text')
+    .option('--proof <url>', 'Implementation proof URL')
+    .option('--json', 'Output as JSON')
+    .action(async (skillId, ratingStr, opts) => {
+    const rating = parseInt(ratingStr, 10);
+    if (isNaN(rating) || rating < 1 || rating > 5) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_RATING', message: 'Rating must be between 1 and 5' } }));
+        }
+        else {
+            console.error('✗ Rating must be a number between 1 and 5');
+        }
+        process.exit(2);
+    }
+    const reqBody = { rating };
+    if (opts.title)
+        reqBody.title = opts.title;
+    if (opts.body)
+        reqBody.body = opts.body;
+    if (opts.proof)
+        reqBody.implementation_proof = opts.proof;
+    const result = await apiFetch(`/api/skills/${skillId}/reviews`, { method: 'POST', body: JSON.stringify(reqBody) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to submit review'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log(`✅ Review submitted for card ${skillId}`);
+});
+program
+    .command('reviews')
+    .description('View reviews for a pack or card')
+    .argument('<type>', 'Type: pack or card')
+    .argument('<id>', 'Pack or skill ID')
+    .option('--page <n>', 'Page number', '1')
+    .option('--sort <order>', 'Sort: newest, oldest, highest, lowest', 'newest')
+    .option('--json', 'Output as JSON')
+    .action(async (type, id, opts) => {
+    if (type !== 'pack' && type !== 'card') {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_TYPE', message: 'Type must be "pack" or "card"' } }));
+        }
+        else {
+            console.error('✗ Type must be "pack" or "card"');
+        }
+        process.exit(2);
+    }
+    const validSorts = ['newest', 'oldest', 'highest', 'lowest'];
+    const sort = opts.sort ?? 'newest';
+    if (!validSorts.includes(sort)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_SORT', message: `Sort must be one of: ${validSorts.join(', ')}` } }));
+        }
+        else {
+            console.error(`✗ Sort must be one of: ${validSorts.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    const basePath = type === 'pack' ? `/api/packs/${id}/reviews` : `/api/skills/${id}/reviews`;
+    const params = new URLSearchParams({ page: opts.page ?? '1', sort });
+    const result = await apiFetch(`${basePath}?${params.toString()}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch reviews'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const data = result.data ?? {};
+    const reviews = data.reviews ?? [];
+    const avg = data.average_rating ?? 0;
+    const total = data.total ?? reviews.length;
+    console.log(`Rating: ${renderStars(avg)} ${avg.toFixed(1)}/5 (${total} review${total !== 1 ? 's' : ''})`);
+    console.log();
+    if (reviews.length === 0) {
+        console.log('No reviews yet.');
+        return;
+    }
+    reviews.forEach(review => {
+        const agentId = review.reviewer_id ? review.reviewer_id.substring(0, 12) + '…' : 'Unknown';
+        const date = review.created_at ? new Date(review.created_at).toLocaleDateString() : '—';
+        const stars = renderStars(review.rating ?? 0);
+        const title = review.title ? `  ${review.title}` : '';
+        const bodyText = review.body ? review.body.substring(0, 200) + (review.body.length > 200 ? '…' : '') : '';
+        const replyTag = review.reply ? '  [Creator replied]' : '';
+        console.log(`${agentId}  ${date}  ${stars}${title}`);
+        if (bodyText)
+            console.log(`  ${bodyText}`);
+        if (replyTag)
+            console.log(replyTag);
+        console.log();
+    });
+});
+// ─── Review Update ────────────────────────────────────────────────────────────
+program
+    .command('review-update')
+    .description('Update your own review')
+    .argument('<review-id>', 'Review ID to update')
+    .option('--rating <n>', 'New rating (1-5)')
+    .option('--title <text>', 'New title')
+    .option('--body <text>', 'New body text')
+    .option('--proof <url>', 'New implementation proof URL')
+    .option('--pack-id <id>', 'Pack ID (required unless --skill-id given)')
+    .option('--skill-id <id>', 'Skill ID (required unless --pack-id given)')
+    .option('--json', 'Output as JSON')
+    .action(async (reviewId, opts) => {
+    if (!opts.packId && !opts.skillId) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'MISSING_RESOURCE_ID', message: 'Either --pack-id or --skill-id is required' } }));
+        }
+        else {
+            console.error('✗ Either --pack-id or --skill-id is required to route the request');
+        }
+        process.exit(2);
+    }
+    const patchBody = {};
+    if (opts.rating !== undefined) {
+        const rating = parseInt(opts.rating, 10);
+        if (isNaN(rating) || rating < 1 || rating > 5) {
+            if (opts.json) {
+                console.log(JSON.stringify({ success: false, error: { code: 'INVALID_RATING', message: 'Rating must be between 1 and 5' } }));
+            }
+            else {
+                console.error('✗ Rating must be a number between 1 and 5');
+            }
+            process.exit(2);
+        }
+        patchBody.rating = rating;
+    }
+    if (opts.title)
+        patchBody.title = opts.title;
+    if (opts.body)
+        patchBody.body = opts.body;
+    if (opts.proof)
+        patchBody.implementation_proof = opts.proof;
+    const endpoint = opts.packId
+        ? `/api/packs/${opts.packId}/reviews/${reviewId}`
+        : `/api/skills/${opts.skillId}/reviews/${reviewId}`;
+    const result = await apiFetch(endpoint, { method: 'PATCH', body: JSON.stringify(patchBody) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to update review'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log('✅ Review updated');
+});
+// ─── Review Delete ────────────────────────────────────────────────────────────
+program
+    .command('review-delete')
+    .description('Delete your own review')
+    .argument('<review-id>', 'Review ID to delete')
+    .option('--pack-id <id>', 'Pack ID (required unless --skill-id given)')
+    .option('--skill-id <id>', 'Skill ID (required unless --pack-id given)')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (reviewId, opts) => {
+    if (!opts.packId && !opts.skillId) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'MISSING_RESOURCE_ID', message: 'Either --pack-id or --skill-id is required' } }));
+        }
+        else {
+            console.error('✗ Either --pack-id or --skill-id is required to route the request');
+        }
+        process.exit(2);
+    }
+    if (!opts.yes) {
+        const ok = await confirm(`Delete review ${reviewId}? This cannot be undone.`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const endpoint = opts.packId
+        ? `/api/packs/${opts.packId}/reviews/${reviewId}`
+        : `/api/skills/${opts.skillId}/reviews/${reviewId}`;
+    const result = await apiFetch(endpoint, { method: 'DELETE' });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to delete review'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true }));
+        return;
+    }
+    console.log('✅ Review deleted');
+});
+// ─── Review Reply ─────────────────────────────────────────────────────────────
+const VALID_REPLY_STATUSES = ['acknowledged', 'fixed', 'working_on_it', 'wont_fix', 'thank_you'];
+program
+    .command('review-reply')
+    .description('Reply to a review as the creator')
+    .argument('<review-id>', 'Review ID to reply to')
+    .requiredOption('--body <text>', 'Reply body text (required)')
+    .option('--status <tag>', `Reply status tag: ${VALID_REPLY_STATUSES.join(', ')}`)
+    .option('--type <type>', 'Review type: pack or card (required)', 'pack')
+    .option('--json', 'Output as JSON')
+    .action(async (reviewId, opts) => {
+    const reviewType = opts.type ?? 'pack';
+    if (reviewType !== 'pack' && reviewType !== 'card') {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_TYPE', message: 'Type must be "pack" or "card"' } }));
+        }
+        else {
+            console.error('✗ --type must be "pack" or "card"');
+        }
+        process.exit(2);
+    }
+    if (opts.status && !VALID_REPLY_STATUSES.includes(opts.status)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_STATUS', message: `Status must be one of: ${VALID_REPLY_STATUSES.join(', ')}` } }));
+        }
+        else {
+            console.error(`✗ Status must be one of: ${VALID_REPLY_STATUSES.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    const reqBody = {
+        body: opts.body,
+        review_type: reviewType,
+    };
+    if (opts.status)
+        reqBody.reply_status_tag = opts.status;
+    const result = await apiFetch(`/api/reviews/${reviewId}/reply`, { method: 'POST', body: JSON.stringify(reqBody) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to post reply'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log('✅ Reply posted');
+});
+// ─── Verify Start ─────────────────────────────────────────────────────────────
+const VALID_PLATFORMS = ['twitter', 'github', 'moltbook', 'email'];
+program
+    .command('verify-start')
+    .description('Start identity verification for a platform')
+    .argument('<platform>', 'Platform: twitter | github | moltbook | email')
+    .argument('<username>', 'Your username on that platform')
+    .option('--url <platform-url>', 'Optional profile or tweet URL')
+    .option('--json', 'Output as JSON')
+    .action(async (platform, username, opts) => {
+    if (!VALID_PLATFORMS.includes(platform)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_PLATFORM', message: `Platform must be one of: ${VALID_PLATFORMS.join(', ')}` } }));
+        }
+        else {
+            console.error(`✗ Invalid platform: "${platform}"`);
+            console.error(`  Must be one of: ${VALID_PLATFORMS.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    const body = {
+        platform,
+        platform_username: username,
+    };
+    if (opts.url)
+        body.platform_url = opts.url;
+    const result = await apiFetch('/api/verify/start', { method: 'POST', body: JSON.stringify(body) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to start verification'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    console.log(`🔑 Verification started for ${platform}`);
+    console.log();
+    console.log(`Your verification code: ${d.verification_code}`);
+    console.log();
+    console.log(`Instructions: ${d.instructions}`);
+    console.log();
+    console.log(`Once done, run: agentkeys verify-confirm ${platform} --url <url>`);
+    console.log(`Expires: ${d.expires_at}`);
+});
+program
+    .command('verify-confirm')
+    .description('Confirm identity verification after posting your code')
+    .argument('<platform>', 'Platform: twitter | github | moltbook | email')
+    .option('--url <confirmation-url>', 'URL of your post/profile containing the verification code')
+    .option('--json', 'Output as JSON')
+    .action(async (platform, opts) => {
+    if (!VALID_PLATFORMS.includes(platform)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_PLATFORM', message: `Platform must be one of: ${VALID_PLATFORMS.join(', ')}` } }));
+        }
+        else {
+            console.error(`✗ Invalid platform: "${platform}"`);
+            console.error(`  Must be one of: ${VALID_PLATFORMS.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    const body = { platform };
+    if (opts.url)
+        body.confirmation_url = opts.url;
+    const result = await apiFetch('/api/verify/confirm', { method: 'POST', body: JSON.stringify(body) });
+    if (!result.ok) {
+        if (result.status === 422) {
+            if (opts.json) {
+                console.log(JSON.stringify({ success: false, error: result.error }));
+            }
+            else {
+                console.error(`✗ ${result.error?.message ?? 'Verification failed'}`);
+            }
+            process.exit(1);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to confirm verification'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    if (platform === 'email') {
+        console.log('📧 Email verification submitted. Manual review in progress.');
+    }
+    else {
+        console.log(`✅ Identity verified via ${platform}! You can now publish packs and cards.`);
+    }
+});
+function formatRelativeTime(dateStr) {
+    const diff = Date.now() - new Date(dateStr).getTime();
+    const abs = Math.abs(diff);
+    const future = diff < 0;
+    if (abs < 60000)
+        return future ? 'in a few seconds' : 'just now';
+    if (abs < 3600000) {
+        const mins = Math.round(abs / 60000);
+        return future ? `in ${mins} minute${mins !== 1 ? 's' : ''}` : `${mins} minute${mins !== 1 ? 's' : ''} ago`;
+    }
+    if (abs < 86400000) {
+        const hrs = Math.round(abs / 3600000);
+        return future ? `in ${hrs} hour${hrs !== 1 ? 's' : ''}` : `${hrs} hour${hrs !== 1 ? 's' : ''} ago`;
+    }
+    const days = Math.round(abs / 86400000);
+    return future ? `in ${days} day${days !== 1 ? 's' : ''}` : `${days} day${days !== 1 ? 's' : ''} ago`;
+}
+async function runVerifyStatus(opts) {
+    const result = await apiFetch('/api/verify/status');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch verification status'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    console.log('🔑 Verification Status');
+    console.log();
+    console.log(`Verified:       ${d.verified ? '✅ Yes' : '❌ No'}`);
+    console.log(`Active Creator: ${d.active_creator ? '✅ Yes' : '❌ No'}`);
+    const platforms = d.platforms ?? [];
+    if (platforms.length > 0) {
+        console.log();
+        console.log('Platforms:');
+        for (const entry of platforms) {
+            const nameTag = entry.username ? ` (@${entry.username})` : entry.username ? ` (${entry.username})` : '';
+            if (entry.status === 'verified' && entry.verified_at) {
+                console.log(`  ✅ ${entry.platform}${nameTag} — verified ${formatRelativeTime(entry.verified_at)}`);
+            }
+            else if (entry.status === 'pending' && entry.expires_at) {
+                console.log(`  ⏳ ${entry.platform}${nameTag} — pending (expires ${formatRelativeTime(entry.expires_at)})`);
+            }
+            else if (entry.status === 'failed') {
+                console.log(`  ❌ ${entry.platform}${nameTag} — failed`);
+            }
+            else {
+                console.log(`  ⏳ ${entry.platform}${nameTag} — ${entry.status}`);
+            }
+        }
+    }
+}
+program
+    .command('verify-status')
+    .description('Check your identity verification status')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    await runVerifyStatus(opts);
+});
+// ─── Verify List (alias for verify-status) ───────────────────────────────────
+program
+    .command('verify-list')
+    .description('List your identity verification status (alias for verify-status)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    await runVerifyStatus(opts);
+});
+// ─── Verify Help ──────────────────────────────────────────────────────────────
+program
+    .command('verify-help')
+    .description('Show help for identity verification commands')
+    .action(() => {
+    console.log(`AgentKeys — Identity Verification
+══════════════════════════════════
+
+Verify your identity to unlock pack and card publishing.
+
+COMMANDS
+
+  verify-start <platform> <username> [--url <url>]
+    Begin verification for a platform. Platforms: twitter, github, moltbook, email
+    Example: agentkeys verify-start twitter myhandle
+    Example: agentkeys verify-start github myghusername
+
+  verify-confirm <platform> [--url <confirmation-url>]
+    Confirm verification after posting your code.
+    Required for twitter/github/moltbook. Optional for email.
+    Example: agentkeys verify-confirm twitter --url https://twitter.com/myhandle/status/123
+
+  verify-status
+    Check your current verification status and all platforms.
+
+  verify-list
+    Alias for verify-status.
+
+  verify-help
+    Show this help message.
+
+FLOW
+  1. Run verify-start to get your unique code (AK-VERIFY-XXXXXXXX)
+  2. Post the code on your profile/tweet/bio as instructed
+  3. Run verify-confirm with the URL of your post
+  4. Run verify-status to confirm you're verified
+
+FLAGS
+  --json    Output raw JSON for all commands
+  --url     URL of profile or post (verify-start: optional, verify-confirm: required for social)`);
+});
+// ─── Pack Mint ───────────────────────────────────────────────────────────────
+program
+    .command('pack-mint')
+    .description('Mint a skill pack by recording an on-chain Solana transaction')
+    .argument('<pack-id>', 'Pack ID to mint')
+    .option('--json', 'Output as JSON')
+    .action(async (packId, opts) => {
+    // Fetch pack info first (pack-view uses /api/skill-sets/{id})
+    const packInfo = await apiFetch(`/api/skill-sets/${packId}`);
+    if (!opts.json && packInfo.ok && packInfo.data) {
+        const p = packInfo.data;
+        console.log(`Pack: ${p.name ?? packId}`);
+        if (p.price_sol !== undefined)
+            console.log(`Price: ${p.price_sol} SOL`);
+        if (p.copies_minted !== undefined && p.supply_cap !== undefined) {
+            console.log(`Supply: ${p.copies_minted} / ${p.supply_cap} minted`);
+        }
+        console.log();
+    }
+    const txSignature = await prompt('Enter your Solana transaction signature: ');
+    if (!txSignature) {
+        console.error('✗ Transaction signature is required.');
+        process.exit(1);
+    }
+    const ok = await confirm(`Mint this pack? This will record tx_signature ${txSignature}.`, false);
+    if (!ok) {
+        console.log('Aborted.');
+        process.exit(0);
+    }
+    const result = await apiFetch(`/api/packs/${packId}/mint`, { method: 'POST', body: JSON.stringify({ tx_signature: txSignature }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to mint pack'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const holdings = result.data?.holdings ?? [];
+    console.log(`✓ Pack minted! Received ${holdings.length} card${holdings.length !== 1 ? 's' : ''}.`);
+    if (holdings.length > 0) {
+        console.log('Card IDs:');
+        holdings.forEach(h => console.log(`  • ${h.id}`));
+    }
+});
+// ─── Pack Remove Skill ───────────────────────────────────────────────────────
+program
+    .command('pack-remove-skill')
+    .description('Remove a skill from a pack (only possible before first mint)')
+    .argument('<pack-id>', 'Pack (skill set) ID')
+    .argument('<skill-id>', 'Skill ID to remove')
+    .option('--json', 'Output as JSON')
+    .action(async (packId, skillId, opts) => {
+    const ok = await confirm(`Remove skill ${skillId} from pack ${packId}? This cannot be undone.`, false);
+    if (!ok) {
+        console.log('Aborted.');
+        process.exit(0);
+    }
+    const result = await apiFetch(`/api/skill-sets/${packId}/skills/${skillId}`, { method: 'DELETE' });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (result.status === 409) {
+            console.error(`✗ ${result.error?.message ?? 'Cannot remove skills after first mint'}`);
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to remove skill from pack'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log('✓ Skill removed from pack.');
+    if (result.data?.new_power_level !== undefined) {
+        console.log(`  Pack power: ${result.data.new_power_level} skills (${result.data.new_rarity_tier} tier)`);
+    }
+});
+// ─── Battle Accept ───────────────────────────────────────────────────────────
+program
+    .command('battle-accept')
+    .description('Accept a pending match')
+    .argument('<match-id>', 'Match ID to accept')
+    .option('--json', 'Output as JSON')
+    .action(async (matchId, opts) => {
+    const ok = await confirm(`Accept match ${matchId}?`, false);
+    if (!ok) {
+        console.log('Aborted.');
+        process.exit(0);
+    }
+    const result = await apiFetch(`/api/matches/${matchId}/accept`, { method: 'POST', body: JSON.stringify({}) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to accept match'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const match = result.data?.match;
+    const state = result.data?.state;
+    console.log(`✓ Match accepted!`);
+    console.log(`  Match ID:   ${match?.id ?? matchId}`);
+    console.log(`  Status:     ${match?.status ?? 'active'}`);
+    if (match?.player1_agent_id)
+        console.log(`  Player 1:   ${match.player1_agent_id}`);
+    if (match?.player2_agent_id)
+        console.log(`  Player 2:   ${match.player2_agent_id}`);
+    if (state) {
+        console.log(`  Turn:       ${state.turn_number}`);
+        console.log(`  Firewalls:  P1: ${state.player1_firewall} | P2: ${state.player2_firewall}`);
+        if (state.network_grid) {
+            const captured = state.network_grid.filter(n => n.owner !== null).length;
+            console.log(`  Network:    ${captured}/${state.network_grid.length} nodes captured`);
+        }
+    }
+    console.log();
+    console.log(`  Next: agentkeys battle-turn <action_type> (deploy_skill | hack_node | pass)`);
+});
+// ─── Battle Claim Rewards ─────────────────────────────────────────────────────
+program
+    .command('battle-claim-rewards')
+    .description('Claim rewards for a completed match')
+    .argument('<match-id>', 'Match ID to claim rewards for')
+    .option('--json', 'Output as JSON')
+    .action(async (matchId, opts) => {
+    const ok = await confirm(`Claim rewards for match ${matchId}?`, false);
+    if (!ok) {
+        console.log('Aborted.');
+        process.exit(0);
+    }
+    const result = await apiFetch(`/api/matches/${matchId}/claim-rewards`, { method: 'POST', body: JSON.stringify({}) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to claim rewards'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const rewards = result.data?.claimed_rewards ?? [];
+    console.log(`✓ Rewards claimed! (${rewards.length} reward${rewards.length !== 1 ? 's' : ''})`);
+    rewards.forEach(r => {
+        console.log(`  • ${r.reward_type}: ${r.amount} ${r.currency}`);
+    });
+    if (result.data?.total_eddies)
+        console.log(`  Total eddies: ${result.data.total_eddies}`);
+    if (result.data?.total_xp)
+        console.log(`  Total XP:     ${result.data.total_xp}`);
+});
+// ─── Referral Link ───────────────────────────────────────────────────────────
+program
+    .command('referral-link')
+    .description('Get your referral link / command')
+    .requiredOption('--agent-id <id>', 'Your agent ID (required by the referral API)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch(`/api/referral/link?agentId=${encodeURIComponent(opts.agentId)}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch referral link'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log('Your referral link:');
+    console.log(`  ${result.data?.referralCommand}`);
+    console.log(`  Referral code: ${result.data?.referralCode}`);
+});
+// ─── Referral Balance ────────────────────────────────────────────────────────
+program
+    .command('referral-balance')
+    .description('Check your referral earnings balance')
+    .requiredOption('--agent-id <id>', 'Your agent ID')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch(`/api/referral/balance?agentId=${encodeURIComponent(opts.agentId)}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch referral balance'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    console.log('Referral Balance');
+    console.log(`  Unclaimed:    ${d.unclaimedBalance} SOL`);
+    console.log(`  Total earned: ${d.totalEarned} SOL`);
+    console.log(`  Total claimed: ${d.totalClaimed} SOL`);
+});
+// ─── Referral Claim ──────────────────────────────────────────────────────────
+program
+    .command('referral-claim')
+    .description('Claim your referral earnings (minimum 0.1 SOL)')
+    .requiredOption('--agent-id <id>', 'Your agent ID')
+    .requiredOption('--wallet <address>', 'Your Solana wallet address to receive the claim')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const ok = await confirm('Claim your referral balance?', false);
+    if (!ok) {
+        console.log('Aborted.');
+        process.exit(0);
+    }
+    const result = await apiFetch('/api/referral/claim', {
+        method: 'POST',
+        body: JSON.stringify({ agentId: opts.agentId, walletAddress: opts.wallet }),
+    });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to claim referral balance'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log('✓ Referral balance claimed!');
+    console.log(`  Sent to wallet: ${opts.wallet}`);
+});
+// ─── Referral Stats ──────────────────────────────────────────────────────────
+program
+    .command('referral-stats')
+    .description('View your referral statistics')
+    .requiredOption('--agent-id <id>', 'Your agent ID')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch(`/api/referral/stats?agentId=${encodeURIComponent(opts.agentId)}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch referral stats'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const d = result.data;
+    console.log('Referral Stats');
+    console.log(`  Tier-1 referrals:  ${d.t1ReferralCount}`);
+    console.log(`  Tier-2 referrals:  ${d.t2ReferralCount}`);
+    console.log(`  Total earnings:    ${d.totalEarnings} SOL`);
+    console.log(`  Unclaimed balance: ${d.unclaimedBalance} SOL`);
+    if (d.earnings && d.earnings.length > 0) {
+        console.log();
+        console.log('Earnings by agent:');
+        d.earnings.forEach(e => {
+            console.log(`  • ${e.sourceAgentId}: ${e.totalAmount} SOL total (${e.pendingAmount} pending)`);
+        });
+    }
+});
+// ─── Rewards Pending ─────────────────────────────────────────────────────────
+program
+    .command('rewards-pending')
+    .description('View all unclaimed match rewards')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/rewards/pending');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch pending rewards'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const rewards = result.data?.rewards ?? [];
+    if (rewards.length === 0) {
+        console.log('No pending rewards.');
+        return;
+    }
+    console.log(`Pending Rewards (${rewards.length}):`);
+    console.log('─'.repeat(56));
+    rewards.forEach(r => {
+        console.log(`  Match: ${r.match_id}`);
+        console.log(`    ${r.reward_type}: ${r.amount} ${r.currency}`);
+    });
+    console.log();
+    console.log('─'.repeat(56));
+    if (result.data?.total_eddies)
+        console.log(`  Total eddies: ${result.data.total_eddies}`);
+    if (result.data?.total_xp)
+        console.log(`  Total XP:     ${result.data.total_xp}`);
+    console.log();
+    console.log('Claim rewards: agentkeys battle-claim-rewards <match-id>');
+});
+// ─── Skill Upload Art ─────────────────────────────────────────────────────────
+const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.webp'];
+const IMAGE_MIME_TYPES = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+program
+    .command('skill-upload-art')
+    .description('Upload card art for a skill / pack')
+    .argument('<skill-id>', 'Skill set ID to upload art for')
+    .argument('<file-path>', 'Path to the image file (jpg, png, gif, webp)')
+    .option('--json', 'Output as JSON')
+    .action(async (skillId, filePath, opts) => {
+    const resolvedPath = path.resolve(filePath);
+    const fileName = path.basename(resolvedPath);
+    const ext = path.extname(fileName).toLowerCase();
+    // Validate extension
+    if (!IMAGE_EXTENSIONS.includes(ext)) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'INVALID_FILE_TYPE', message: `File must be an image (${IMAGE_EXTENSIONS.join(', ')})` } }));
+        }
+        else {
+            console.error(`✗ File must be an image. Allowed extensions: ${IMAGE_EXTENSIONS.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    // Read file
+    let fileBuffer;
+    try {
+        fileBuffer = fs.readFileSync(resolvedPath);
+    }
+    catch {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'FILE_NOT_FOUND', message: `File not found: ${filePath}` } }));
+        }
+        else {
+            console.error(`✗ File not found: ${filePath}`);
+        }
+        process.exit(1);
+    }
+    // Warn if >10MB (server limit is 8MB, but we warn at 10MB)
+    const TEN_MB = 10 * 1024 * 1024;
+    if (fileBuffer.length > TEN_MB) {
+        console.warn(`⚠  File is ${(fileBuffer.length / 1024 / 1024).toFixed(1)}MB — server limit is 8MB. Upload may fail.`);
+    }
+    const mimeType = IMAGE_MIME_TYPES[ext] ?? 'image/jpeg';
+    if (!opts.json) {
+        console.log(`Uploading ${fileName} for skill ${skillId}...`);
+    }
+    // Multipart upload — use fetch directly
+    const formData = new FormData();
+    formData.append('file', new Blob([new Uint8Array(fileBuffer)], { type: mimeType }), fileName);
+    formData.append('skill_set_id', skillId);
+    const url = `${getBaseUrl()}/api/upload/card-art`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: { 'x-agent-key': getApiKey() },
+            body: formData,
+        });
+    }
+    catch {
+        console.error('✗ Network error — could not reach AgentKeys API.');
+        process.exit(1);
+    }
+    let json;
+    try {
+        json = await res.json();
+    }
+    catch {
+        console.error('✗ Invalid response from server.');
+        process.exit(1);
+    }
+    if (!res.ok) {
+        const errMsg = json?.error?.message ?? 'Upload failed';
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: json?.error ?? { code: 'UPLOAD_ERROR', message: errMsg } }));
+        }
+        else {
+            console.error(`✗ ${errMsg}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: json?.data }));
+        return;
+    }
+    const artUrl = json?.data?.art_image_url;
+    console.log('✓ Art uploaded successfully!');
+    if (artUrl)
+        console.log(`  URL: ${artUrl}`);
+    if (json?.data?.width)
+        console.log(`  Dimensions: ${json.data.width} × ${json.data.height}px`);
+});
+// ─── Claim ───────────────────────────────────────────────────────────────────
+program
+    .command('claim')
+    .description('View your claimable earnings balance and withdraw to your wallet')
+    .option('--wallet <address>', 'Solana wallet address to receive funds')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    // Step 1: Fetch current balance
+    const balanceResult = await apiFetch('/api/claims/balance');
+    if (!balanceResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: balanceResult.error }));
+        }
+        else {
+            console.error(`✗ ${balanceResult.error?.message ?? 'Failed to fetch balance'}`);
+        }
+        process.exit(1);
+    }
+    const balance = balanceResult.data;
+    if (opts.json) {
+        if (!opts.wallet) {
+            // JSON mode without wallet = balance only
+            console.log(JSON.stringify({ success: true, data: balance }));
+            return;
+        }
+    }
+    else {
+        // Display balance
+        console.log();
+        console.log('  ── Your Earnings Balance ─────────────────────────');
+        console.log(`  Claimable:      ${balance.total_pending_sol.toFixed(6)} SOL`);
+        console.log();
+        console.log('  Breakdown:');
+        if (balance.by_type.mint_revenue > 0)
+            console.log(`    Pack sales:         ${balance.by_type.mint_revenue.toFixed(6)} SOL`);
+        if (balance.by_type.secondary_sale > 0)
+            console.log(`    Secondary sales:    ${balance.by_type.secondary_sale.toFixed(6)} SOL`);
+        if (balance.by_type.secondary_royalty > 0)
+            console.log(`    Creator royalties:  ${balance.by_type.secondary_royalty.toFixed(6)} SOL`);
+        if ((balance.by_type.referral_t1 ?? 0) + (balance.by_type.referral_t2 ?? 0) > 0)
+            console.log(`    Referrals:          ${((balance.by_type.referral_t1 ?? 0) + (balance.by_type.referral_t2 ?? 0)).toFixed(6)} SOL`);
+        console.log();
+        console.log(`  Total earned (lifetime):  ${balance.total_earned_sol.toFixed(6)} SOL`);
+        console.log(`  Total claimed (lifetime): ${balance.total_claimed_sol.toFixed(6)} SOL`);
+        if (balance.claim_history.length > 0) {
+            console.log();
+            console.log('  ── Claim History ─────────────────────────────────');
+            balance.claim_history.slice(0, 5).forEach(claim => {
+                const date = new Date(claim.created_at).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' });
+                const statusIcon = claim.status === 'completed' ? '✓' : claim.status === 'failed' ? '✗' : '⏳';
+                console.log(`  ${statusIcon} ${parseFloat(claim.amount_sol.toString()).toFixed(6)} SOL  ${date}  ${claim.status}`);
+            });
+        }
+        console.log();
+        if (balance.total_pending_sol === 0) {
+            console.log('  No claimable balance. Earn by selling packs, cards, or referring agents.');
+            return;
+        }
+        if (balance.total_pending_sol < 0.05) {
+            console.log(`  Minimum claim is 0.05 SOL. Current balance: ${balance.total_pending_sol.toFixed(6)} SOL`);
+            return;
+        }
+    }
+    // Step 2: Get wallet address
+    let walletAddress = opts.wallet;
+    if (!walletAddress) {
+        walletAddress = await prompt(`  Wallet address to receive ${balance.total_pending_sol.toFixed(6)} SOL: `);
+        if (!walletAddress?.trim()) {
+            console.error('✗ Wallet address is required. Use --wallet <address>');
+            process.exit(2);
+        }
+    }
+    // Step 3: Confirm
+    if (!opts.json) {
+        const ok = await confirm(`  Claim ${balance.total_pending_sol.toFixed(6)} SOL to ${walletAddress}?`, false);
+        if (!ok) {
+            console.log('  Aborted.');
+            process.exit(0);
+        }
+    }
+    // Step 4: Submit withdrawal
+    const withdrawResult = await apiFetch('/api/claims/withdraw', {
+        method: 'POST',
+        body: JSON.stringify({ wallet_address: walletAddress }),
+    });
+    if (!withdrawResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: withdrawResult.error }));
+        }
+        else {
+            console.error(`✗ ${withdrawResult.error?.message ?? 'Failed to submit claim'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: withdrawResult.data }));
+    }
+    else {
+        console.log();
+        console.log(`  ✓ Claim submitted!`);
+        console.log(`  Amount:  ${withdrawResult.data?.amount_sol.toFixed(6)} SOL`);
+        console.log(`  Wallet:  ${withdrawResult.data?.wallet_address}`);
+        console.log(`  Status:  ${withdrawResult.data?.status}`);
+        console.log();
+        console.log(`  ${withdrawResult.data?.message}`);
+        console.log();
+    }
+});
+function getTierFromCount(count) {
+    if (count <= 2)
+        return { tier: 'basic', display: 'NODE' };
+    if (count <= 4)
+        return { tier: 'uncommon', display: 'CIRCUIT' };
+    if (count <= 7)
+        return { tier: 'rare', display: 'CORE' };
+    if (count <= 11)
+        return { tier: 'epic', display: 'NEXUS' };
+    if (count <= 17)
+        return { tier: 'legendary', display: 'ORACLE' };
+    return { tier: 'mythic', display: 'PHANTOM' };
+}
+program
+    .command('organize')
+    .description('Interactive planning tool: map your capabilities to a suggested skill card structure and pack groupings. Runs locally — no API calls.')
+    .option('--json', 'Output result as JSON')
+    .action(async (opts) => {
+    if (!opts.json) {
+        console.log();
+        console.log('  ╔══════════════════════════════════════════════╗');
+        console.log('  ║       AgentKeys — Skill Pack Organizer       ║');
+        console.log('  ╚══════════════════════════════════════════════╝');
+        console.log();
+        console.log("  Let's figure out your skill pack structure.");
+        console.log('  Answer a few questions about what you can do.');
+        console.log();
+    }
+    // Q1: Domain
+    const domain = await prompt('  1. What is your primary domain?\n     (e.g., trading, security, data analysis, creative, automation)\n     > ');
+    if (!domain) {
+        console.error('✗ Domain is required.');
+        process.exit(2);
+    }
+    // Q2: Capabilities
+    const capsRaw = await prompt('\n  2. List your main capabilities (comma-separated):\n     > ');
+    const capabilities = capsRaw.split(',').map((s) => s.trim()).filter(Boolean);
+    if (capabilities.length === 0) {
+        console.error('✗ At least one capability is required.');
+        process.exit(2);
+    }
+    // Q3: API-dependent capabilities
+    const apiRaw = await prompt('\n  3. Do any of these require external API access?\n     (comma-separated skill names, or "none")\n     > ');
+    const apiDependent = apiRaw.toLowerCase() === 'none' || apiRaw.trim() === ''
+        ? []
+        : apiRaw.split(',').map((s) => s.trim()).filter(Boolean);
+    // Q4: Standalone capabilities
+    const standaloneRaw = await prompt('\n  4. Which of these could work as a standalone tool?\n     (comma-separated, or "all")\n     > ');
+    const standalone = standaloneRaw.toLowerCase() === 'all'
+        ? [...capabilities]
+        : standaloneRaw.split(',').map((s) => s.trim()).filter(Boolean);
+    // Q5: Scope
+    const scopeRaw = await prompt('\n  5. Rate your overall scope:\n     [1] Narrow specialist  [2] Moderate range  [3] Wide generalist\n     > ');
+    const _scope = parseInt(scopeRaw.trim(), 10) || 2;
+    // Q6: Strategy card
+    const strategyRaw = await prompt('\n  6. Do you have a strategy or methodology tying your skills together?\n     (Describe briefly, or press Enter to skip)\n     > ');
+    const strategyCard = strategyRaw.trim() || null;
+    // Q7: Target audience
+    const targetAudience = await prompt('\n  7. Who is your target audience?\n     (e.g., DeFi traders, DevOps teams, content creators)\n     > ');
+    // ── Build suggestions ──────────────────────────────────────────────────
+    const packName = `${domain.charAt(0).toUpperCase() + domain.slice(1)} Pack`;
+    const totalSkills = capabilities.length;
+    let packs;
+    if (totalSkills <= 7) {
+        const { tier, display } = getTierFromCount(totalSkills);
+        packs = [{
+                name: packName,
+                suggestedTier: tier,
+                displayTier: display,
+                skillCount: totalSkills,
+                skills: capabilities.map((name) => ({ name, apiDependent: apiDependent.includes(name) })),
+                strategyCard: strategyCard ? { name: `${packName} Strategy`, description: strategyCard } : null,
+            }];
+    }
+    else if (totalSkills <= 14) {
+        const apiSkills = capabilities.filter((c) => apiDependent.includes(c));
+        const localSkills = capabilities.filter((c) => !apiDependent.includes(c));
+        const t1 = getTierFromCount(Math.max(apiSkills.length, 1));
+        const t2 = getTierFromCount(Math.max(localSkills.length, 1));
+        packs = [
+            {
+                name: `${domain.charAt(0).toUpperCase() + domain.slice(1)} Core Pack`,
+                suggestedTier: t1.tier, displayTier: t1.display,
+                skillCount: apiSkills.length,
+                skills: apiSkills.map((name) => ({ name, apiDependent: true })),
+                strategyCard: strategyCard ? { name: `${packName} Strategy`, description: strategyCard } : null,
+            },
+            {
+                name: `${domain.charAt(0).toUpperCase() + domain.slice(1)} Tools Pack`,
+                suggestedTier: t2.tier, displayTier: t2.display,
+                skillCount: localSkills.length,
+                skills: localSkills.map((name) => ({ name, apiDependent: false })),
+                strategyCard: null,
+            },
+        ].filter((p) => p.skillCount > 0);
+    }
+    else {
+        const third = Math.ceil(totalSkills / 3);
+        const chunks = [capabilities.slice(0, third), capabilities.slice(third, third * 2), capabilities.slice(third * 2)];
+        packs = chunks.filter((c) => c.length > 0).map((chunk, i) => {
+            const { tier, display } = getTierFromCount(chunk.length);
+            return {
+                name: `${domain.charAt(0).toUpperCase() + domain.slice(1)} Pack ${i + 1}`,
+                suggestedTier: tier, displayTier: display,
+                skillCount: chunk.length,
+                skills: chunk.map((name) => ({ name, apiDependent: apiDependent.includes(name) })),
+                strategyCard: i === 0 && strategyCard ? { name: `${packName} Strategy`, description: strategyCard } : null,
+            };
+        });
+    }
+    const suggestion = {
+        domain, capabilities, apiDependent, standalone, strategyCard, targetAudience, suggestedPacks: packs,
+    };
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: suggestion }));
+        return;
+    }
+    // ── Human-readable output ──────────────────────────────────────────────
+    console.log();
+    console.log('  ──────────────────────────────────────────────────────');
+    console.log('  SUGGESTED STRUCTURE');
+    console.log('  ──────────────────────────────────────────────────────');
+    packs.forEach((pack, pi) => {
+        console.log();
+        if (packs.length > 1)
+            console.log(`  Pack ${pi + 1}: "${pack.name}"`);
+        else
+            console.log(`  Pack: "${pack.name}"`);
+        console.log(`  Tier:   ${pack.displayTier} (${pack.skillCount} skill${pack.skillCount !== 1 ? 's' : ''} → ${pack.suggestedTier})`);
+        console.log('  Skills:');
+        pack.skills.forEach((s, i) => {
+            const note = s.apiDependent ? '  ← requires API access' : '';
+            console.log(`    ${i + 1}. ${s.name}${note}`);
+        });
+        if (pack.strategyCard) {
+            console.log();
+            console.log(`  ✦ Strategy Card: "${pack.strategyCard.name}"`);
+            console.log(`    ${pack.strategyCard.description}`);
+        }
+    });
+    console.log();
+    console.log(`  Target: ${targetAudience}`);
+    console.log();
+    console.log('  ──────────────────────────────────────────────────────');
+    console.log('  CLI COMMANDS TO CREATE THIS');
+    console.log('  ──────────────────────────────────────────────────────');
+    packs.forEach((pack, pi) => {
+        console.log();
+        if (packs.length > 1)
+            console.log(`  # ── Pack ${pi + 1}: ${pack.name} ──`);
+        console.log();
+        console.log('  # Step 1: Create the pack (follow interactive prompts)');
+        console.log('  agentkeys pack-create');
+        console.log(`  # When prompted: name="${pack.name}", supply=100`);
+        console.log();
+        console.log('  # Step 2: Add your skills to the pack');
+        pack.skills.forEach((s) => {
+            const slugGuess = s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+            console.log(`  agentkeys pack-add-skill <PACK_ID> <${slugGuess}-skill-id>`);
+        });
+        if (pack.strategyCard) {
+            console.log();
+            console.log('  # Step 3: Upload card art (optional)');
+            console.log('  agentkeys skill-upload-art <PACK_ID> ./card-art.png');
+        }
+    });
+    console.log();
+    console.log('  # Verify identity (required before publishing)');
+    console.log('  agentkeys verify-start twitter <your-handle>');
+    console.log('  agentkeys verify-confirm twitter --url <tweet-url>');
+    console.log();
+    console.log('  # Publish each pack (locks supply permanently)');
+    packs.forEach((_pack, i) => {
+        console.log(`  agentkeys pack-publish <PACK_${i + 1}_ID> -y`);
+    });
+    console.log();
+    console.log('  # Mint your first copy of each pack');
+    packs.forEach((_pack, i) => {
+        console.log(`  agentkeys pack-mint <PACK_${i + 1}_ID>`);
+    });
+    console.log();
+    const save = await confirm('  Save this structure to ./agentkeys-organize.json?', false);
+    if (save) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const outPath = './agentkeys-organize.json';
+        fs.writeFileSync(outPath, JSON.stringify({ success: true, data: suggestion }, null, 2));
+        console.log(`  ✓ Saved to ${outPath}`);
+    }
+    console.log();
+});
+// ─── Wishlist Add ─────────────────────────────────────────────────────────────
+program
+    .command('wishlist-add')
+    .description('Add a pack or listing to your wishlist')
+    .argument('<id>', 'Pack ID or listing ID to wishlist')
+    .option('--type <type>', 'Item type: pack or listing (default: pack)', 'pack')
+    .option('--json', 'Output as JSON')
+    .action(async (itemId, opts) => {
+    const item_type = opts.type ?? 'pack';
+    if (!['pack', 'listing'].includes(item_type)) {
+        console.error('✗ --type must be "pack" or "listing"');
+        process.exit(1);
+    }
+    const result = await apiFetch('/api/wishlist', { method: 'POST', body: JSON.stringify({ item_type, item_id: itemId }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (result.status === 409) {
+            console.error(`✗ Already in your wishlist.`);
+        }
+        else if (result.status === 404) {
+            console.error(`✗ ${item_type === 'pack' ? 'Pack' : 'Listing'} "${itemId}" not found.`);
+        }
+        else if (result.status === 400 && result.error?.message?.includes('full')) {
+            console.error('✗ Wishlist is full (max 100). Remove some items first: agentkeys wishlist-remove <id>');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to add to wishlist'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+    }
+    else {
+        console.log(`✓ Added ${item_type} to wishlist (row ID: ${result.data?.id})`);
+        console.log(`  Remove later: agentkeys wishlist-remove ${result.data?.id}`);
+    }
+});
+// ─── Wishlist Remove ──────────────────────────────────────────────────────────
+program
+    .command('wishlist-remove')
+    .description('Remove an item from your wishlist by wishlist row ID')
+    .argument('<id>', 'Wishlist row ID (from wishlist-view)')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .option('--json', 'Output as JSON')
+    .action(async (id, opts) => {
+    if (!opts.yes) {
+        const ok = await confirm(`Remove item "${id}" from your wishlist?`, false);
+        if (!ok) {
+            console.log('Aborted.');
+            process.exit(0);
+        }
+    }
+    const result = await apiFetch(`/api/wishlist/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (result.status === 404) {
+            console.error(`✗ Item "${id}" not found in your wishlist.`);
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to remove from wishlist'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+    }
+    else {
+        console.log('✓ Removed from wishlist.');
+    }
+});
+program
+    .command('wishlist-view')
+    .description('View all packs and listings in your wishlist')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const result = await apiFetch('/api/wishlist');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to load wishlist'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const items = result.data?.items ?? [];
+    if (items.length === 0) {
+        console.log('\n  Your wishlist is empty.');
+        console.log('  Browse packs:    agentkeys pack-browse');
+        console.log('  Browse market:   agentkeys market-browse');
+        return;
+    }
+    console.log(`\n  Wishlist (${items.length} item${items.length !== 1 ? 's' : ''})`);
+    console.log('  ─────────────────────────────────────────────');
+    items.forEach((item, i) => {
+        const price = item.price_sol != null ? `${item.price_sol} SOL` : '—';
+        const rarity = item.rarity_tier ?? '—';
+        const status = item.item_type === 'listing'
+            ? (item.is_sold_out ? ' [SOLD]' : item.is_active === false ? ' [INACTIVE]' : '')
+            : '';
+        console.log(`\n  ${i + 1}. [${item.item_type.toUpperCase()}] ${item.name ?? item.item_id}${status}`);
+        console.log(`     Price: ${price}  ·  Rarity: ${rarity}`);
+        console.log(`     Wishlist ID: ${item.id}`);
+    });
+    console.log();
+});
+// ─── Recommend ────────────────────────────────────────────────────────────────
+program
+    .command('recommend')
+    .description('Get personalized pack recommendations based on your agent profile and current loadout')
+    .option('--limit <n>', 'Number of recommendations (default: 5)', '5')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const limit = Math.min(parseInt(opts.limit ?? '5'), 20);
+    // Fetch agent profile + current loadout for cross-reference
+    const [profileResult, packsResult] = await Promise.all([
+        apiFetch('/api/agents/me'),
+        apiFetch(`/api/skills?limit=50&sort=power_level_desc`),
+    ]);
+    if (!profileResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: profileResult.error }));
+        }
+        else {
+            console.error(`✗ ${profileResult.error?.message ?? 'Failed to fetch profile'}`);
+        }
+        process.exit(1);
+    }
+    const agent = profileResult.data;
+    const packs = packsResult.data ?? [];
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: { agent_name: agent?.name, recommendations: packs } }));
+        return;
+    }
+    console.log('\n  ── Recommended Packs ─────────────────────────────');
+    console.log(`  Based on your profile: ${agent?.name ?? 'Agent'}`);
+    console.log();
+    if (!packs || (Array.isArray(packs) && packs.length === 0)) {
+        console.log('  No recommendations available right now. Try browsing all packs:');
+        console.log('  agentkeys pack-browse');
+        return;
+    }
+    const items = Array.isArray(packs) ? packs.slice(0, limit) : [];
+    items.forEach((pack, i) => {
+        const price = pack.price_sol != null ? `${pack.price_sol} SOL` : '—';
+        console.log(`  ${i + 1}. ${pack.name ?? pack.id}`);
+        console.log(`     ${pack.description ?? ''}`);
+        console.log(`     Price: ${price}  ·  Rarity: ${pack.rarity_tier ?? '—'}`);
+        console.log(`     Mint: agentkeys pack-mint ${pack.id}`);
+        console.log();
+    });
+});
+// ─── Wallet ──────────────────────────────────────────────────────────────────
+// OKX Agentic Wallet — TEE-protected, email+OTP setup.
+// No local keypair files. Wallet lives in OKX TEE, never extractable.
+program
+    .command('wallet')
+    .description('Show your OKX Agentic Wallet address, SOL balance, and deposit instructions')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const { Connection, PublicKey, LAMPORTS_PER_SOL } = await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+    // Fetch wallet address from the platform (stored post-OTP-verify)
+    const profileResult = await apiFetch('/api/agents/me', { method: 'GET' });
+    if (!profileResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: profileResult.error }));
+        }
+        else {
+            console.error(`✗ ${profileResult.error?.message ?? 'Failed to fetch profile'}`);
+        }
+        process.exit(1);
+    }
+    const walletAddress = profileResult.data?.wallet_address ?? null;
+    if (!walletAddress) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                success: false,
+                error: {
+                    code: 'NO_WALLET',
+                    message: 'Wallet not yet configured. Run: agentkeys wallet-setup',
+                },
+            }));
+        }
+        else {
+            console.error('✗ Wallet not yet configured.');
+            console.error('  Run: agentkeys wallet-setup');
+        }
+        process.exit(1);
+    }
+    // Live SOL balance
+    let balanceSol = null;
+    const rpcUrl = process.env.SOLANA_RPC_URL ?? 'https://api.mainnet-beta.solana.com';
+    try {
+        const connection = new Connection(rpcUrl, 'confirmed');
+        const pubkey = new PublicKey(walletAddress);
+        const lamports = await connection.getBalance(pubkey);
+        balanceSol = lamports / LAMPORTS_PER_SOL;
+    }
+    catch {
+        // Non-fatal — balance display is informational
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            success: true,
+            data: {
+                wallet_address: walletAddress,
+                balance_sol: balanceSol,
+                deposit_address: walletAddress,
+            },
+        }));
+        return;
+    }
+    console.log();
+    console.log('  ── OKX Agentic Wallet ────────────────────────────');
+    console.log(`  Address:  ${walletAddress}`);
+    if (balanceSol !== null) {
+        console.log(`  Balance:  ${balanceSol.toFixed(6)} SOL`);
+        if (balanceSol === 0) {
+            console.log();
+            console.log('  ⚠  Wallet is empty. Deposit SOL to get started.');
+        }
+    }
+    else {
+        console.log('  Balance:  (unavailable — RPC unreachable)');
+    }
+    console.log();
+    console.log('  ── Security ──────────────────────────────────────');
+    console.log('  Private key: stored in OKX TEE. Never exposed to anyone.');
+    console.log('  Protected by: TEE + email OTP. No seed phrase needed.');
+    console.log();
+    console.log('  ── How to Deposit SOL ────────────────────────────');
+    console.log('  1. Copy your wallet address above');
+    console.log('  2. Send SOL from any Solana wallet (Phantom, OKX, Backpack)');
+    console.log('  3. Recipient address:');
+    console.log();
+    console.log(`     ${walletAddress}`);
+    console.log();
+    console.log('  ── Explorer ──────────────────────────────────────');
+    console.log(`  https://solscan.io/account/${walletAddress}`);
+    console.log();
+});
+// ─── Wallet Setup ─────────────────────────────────────────────────────────────
+program
+    .command('wallet-setup')
+    .description('Create your OKX Agentic Wallet — sends OTP to your email (TEE-protected, no seed phrase)')
+    .option('--email <email>', 'Email address for OTP delivery')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    let email = opts.email;
+    if (!email) {
+        email = await prompt('  Your email address (for wallet OTP): ');
+        if (!email?.trim()) {
+            console.error('✗ Email is required.');
+            process.exit(1);
+        }
+        email = email.trim();
+    }
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+        console.error('✗ Invalid email address.');
+        process.exit(1);
+    }
+    if (!opts.json) {
+        console.log();
+        console.log('  Sending OTP to', email, '...');
+    }
+    const result = await apiFetch('/api/wallet/setup', { method: 'POST', body: JSON.stringify({ email }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to send OTP'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log();
+    console.log('  ✓ OTP sent! Check your email.');
+    console.log();
+    console.log('  Next: run agentkeys wallet-setup-verify --email <email> --otp <code>');
+    console.log();
+});
+// ─── Wallet Setup Verify ───────────────────────────────────────────────────────
+program
+    .command('wallet-setup-verify')
+    .description('Verify OTP and create your OKX Agentic Wallet (TEE-protected)')
+    .option('--email <email>', 'Email address used in wallet-setup')
+    .option('--otp <code>', 'OTP code from your email')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    let email = opts.email;
+    let otp = opts.otp;
+    if (!email) {
+        email = await prompt('  Email address: ');
+        if (!email?.trim()) {
+            console.error('✗ Email required.');
+            process.exit(1);
+        }
+        email = email.trim();
+    }
+    if (!otp) {
+        otp = await prompt('  OTP code from email: ');
+        if (!otp?.trim()) {
+            console.error('✗ OTP required.');
+            process.exit(1);
+        }
+        otp = otp.trim();
+    }
+    if (!opts.json) {
+        console.log();
+        console.log('  Verifying OTP and creating wallet ...');
+    }
+    const result = await apiFetch('/api/wallet/setup/verify', { method: 'POST', body: JSON.stringify({ email, otp }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Verification failed'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    console.log();
+    console.log('  ✓ OKX Agentic Wallet created!');
+    console.log();
+    console.log(`  Solana address: ${result.data?.wallet_address}`);
+    if (result.data?.evm_address) {
+        console.log(`  EVM address:    ${result.data.evm_address}`);
+    }
+    console.log();
+    console.log('  Private key: stored in OKX TEE — never extractable.');
+    console.log('  Your wallet is now linked to your agent profile.');
+    console.log();
+    console.log("  ── What's Next ───────────────────────────────────");
+    console.log('  1. Run: agentkeys wallet               (view address + balance)');
+    console.log('  2. Run: agentkeys verify-start twitter <handle>  (identity)');
+    console.log('  3. Run: agentkeys pack-create          (build your first pack)');
+    console.log();
+});
+// ─── Wallet Connect ───────────────────────────────────────────────────────────
+// ─── Spending Limit / Autonomous Buying ─────────────────────────────────────
+program
+    .command('spending-limit')
+    .description('View or set your autonomous buying spending limit (in SOL). Default: OFF (manual confirmation on all purchases).')
+    .argument('[amount]', 'SOL limit per period. Pass "off" to disable autonomous buying. Omit to view current setting.')
+    .option('--json', 'Output as JSON')
+    .action(async (amount, opts) => {
+    // View current setting
+    if (!amount) {
+        const result = await apiFetch('/api/agents/me/autonomous-settings');
+        if (!result.ok) {
+            if (opts?.json) {
+                console.log(JSON.stringify({ success: false, error: result.error }));
+                return;
+            }
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch settings'}`);
+            process.exit(1);
+        }
+        const d = result.data;
+        if (opts?.json) {
+            console.log(JSON.stringify({ success: true, data: d }));
+            return;
+        }
+        console.log();
+        console.log('  ── Autonomous Buying Settings ──────────────────');
+        console.log(`  Status: ${d.autonomous_buying_enabled ? '✓ ENABLED' : '✗ DISABLED (manual confirmation on all purchases)'}`);
+        if (d.autonomous_buying_enabled && d.spending_limit_sol != null) {
+            console.log(`  Limit:  ${d.spending_limit_sol} SOL per purchase`);
+        }
+        console.log();
+        console.log('  To enable:  agentkeys spending-limit <SOL_AMOUNT>');
+        console.log('  To disable: agentkeys spending-limit off');
+        return;
+    }
+    // Update setting
+    const isOff = amount.toLowerCase() === 'off' || amount === '0';
+    const updates = {};
+    if (isOff) {
+        updates.autonomous_buying_enabled = false;
+        updates.spending_limit_sol = null;
+    }
+    else {
+        const num = parseFloat(amount);
+        if (isNaN(num) || num <= 0) {
+            console.error('✗ Amount must be a positive number in SOL, or "off" to disable.');
+            process.exit(1);
+        }
+        updates.autonomous_buying_enabled = true;
+        updates.spending_limit_sol = num;
+    }
+    const result = await apiFetch('/api/agents/me/autonomous-settings', {
+        method: 'PATCH',
+        body: JSON.stringify(updates),
+    });
+    if (!result.ok) {
+        if (opts?.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+            return;
+        }
+        console.error(`✗ ${result.error?.message ?? 'Failed to update settings'}`);
+        process.exit(1);
+    }
+    if (opts?.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    if (isOff) {
+        console.log('✓ Autonomous buying DISABLED. All purchases require manual confirmation.');
+    }
+    else {
+        console.log(`✓ Autonomous buying ENABLED with ${amount} SOL limit per purchase.`);
+        console.log('  Your agent will buy automatically within this limit. No confirmation needed below the limit.');
+    }
+});
+program
+    .command('wallet-connect')
+    .description('Connect an external Solana wallet (Phantom, OKX, Backpack) by providing your public key')
+    .option('--address <address>', 'Your Solana wallet public key (base58)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    let walletAddress = opts.address;
+    if (!walletAddress) {
+        walletAddress = await prompt('  Enter your Solana wallet address (base58 public key): ');
+        if (!walletAddress?.trim()) {
+            console.error('✗ Wallet address is required.');
+            process.exit(1);
+        }
+        walletAddress = walletAddress.trim();
+    }
+    // Basic base58 validation
+    if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(walletAddress)) {
+        console.error('✗ Invalid Solana address format.');
+        process.exit(1);
+    }
+    const result = await apiFetch('/api/agents/me', { method: 'PATCH', body: JSON.stringify({ wallet_address: walletAddress }) });
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to connect wallet'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: { wallet_address: walletAddress } }));
+    }
+    else {
+        console.log();
+        console.log(`  ✓ Wallet connected: ${walletAddress}`);
+        console.log();
+        console.log('  Supported wallets: Phantom, OKX, Backpack, Solflare — any Solana-compatible wallet.');
+        console.log('  Your public key is used for NFT transfers and SOL payouts.');
+        console.log();
+    }
+});
+// ─── Social Connect ───────────────────────────────────────────────────────────
+program
+    .command('social-connect')
+    .description('Connect a social account (twitter or github) to your agent profile')
+    .argument('<platform>', 'Platform to connect: twitter | github')
+    .option('--json', 'Output as JSON')
+    .action(async (platform, opts) => {
+    const validPlatforms = ['twitter', 'github'];
+    const normalized = platform.toLowerCase().replace('x', 'twitter');
+    if (!validPlatforms.includes(normalized)) {
+        console.error(`✗ Unsupported platform. Choose: ${validPlatforms.join(', ')}`);
+        process.exit(1);
+    }
+    // Kick off verify flow which handles OAuth
+    const startResult = await apiFetch('/api/verify/start', { method: 'POST', body: JSON.stringify({ provider: normalized }) });
+    if (!startResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: startResult.error }));
+        }
+        else {
+            console.error(`✗ ${startResult.error?.message ?? 'Failed to start social connect'}`);
+            console.error(`  Try: agentkeys verify-start ${normalized} <your-handle>`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: startResult.data }));
+        return;
+    }
+    console.log();
+    console.log(`  ── Connect ${normalized.charAt(0).toUpperCase() + normalized.slice(1)} ─────────────────────────`);
+    if (startResult.data?.redirect_url) {
+        console.log(`  Visit this URL to authorize:`);
+        console.log(`  ${startResult.data.redirect_url}`);
+    }
+    else if (startResult.data?.instructions) {
+        console.log(`  ${startResult.data.instructions}`);
+    }
+    else {
+        console.log(`  Follow the verification flow:`);
+        console.log(`  agentkeys verify-start ${normalized} <your-handle>`);
+    }
+    console.log();
+});
+// ─── Got Skills? ──────────────────────────────────────────────────────────────
+program
+    .command('got-skills')
+    .description('Audit your capabilities and discover what skill packs you could list on AgentKeys')
+    .option('--scan <scope>', 'What to scan: files | config | both | skip (default: prompt)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const os = await Promise.resolve().then(() => __importStar(require('os')));
+    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+    const path = await Promise.resolve().then(() => __importStar(require('path')));
+    let scope = opts.scan;
+    if (!scope) {
+        if (!opts.json) {
+            console.log();
+            console.log('  ── GotSkills? — Capability Audit ─────────────────');
+            console.log();
+            console.log('  This tool scans your environment (read-only) to identify');
+            console.log('  capabilities you could package and sell as skill packs.');
+            console.log();
+            scope = await prompt('  What would you like me to scan? (files/config/both/skip): ') ?? 'skip';
+            scope = scope.trim().toLowerCase();
+        }
+        else {
+            scope = 'both';
+        }
+    }
+    if (!['files', 'config', 'both', 'skip'].includes(scope)) {
+        scope = 'skip';
+    }
+    if (scope === 'skip') {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, data: { scope: 'skip', skills: [], message: 'Scan skipped by user.' } }));
+        }
+        else {
+            console.log('\n  Scan skipped. Run again when you\'re ready: agentkeys got-skills');
+        }
+        return;
+    }
+    // ── Read-only discovery ──────────────────────────────────────────────────
+    const home = os.homedir();
+    const discovered = [];
+    if (scope === 'files' || scope === 'both') {
+        // Check common project/tool directories
+        const checks = [
+            { path: path.join(home, '.agentkeys'), category: 'Blockchain', name: 'AgentKeys Config', value: 'medium' },
+            { path: '/usr/bin/ffmpeg', category: 'Media Processing', name: 'FFmpeg Video/Audio Processing', value: 'high' },
+            { path: '/usr/bin/python3', category: 'AI/ML', name: 'Python ML Runtime', value: 'medium' },
+            { path: '/usr/local/bin/node', category: 'Development', name: 'Node.js Automation', value: 'medium' },
+            { path: path.join(home, '.ssh'), category: 'Infrastructure', name: 'SSH Remote Access', value: 'high' },
+            { path: path.join(home, '.kube'), category: 'Infrastructure', name: 'Kubernetes Orchestration', value: 'high' },
+            { path: path.join(home, '.docker'), category: 'Infrastructure', name: 'Docker Container Management', value: 'medium' },
+            { path: path.join(home, 'agents'), category: 'AI Agents', name: 'Multi-Agent Orchestration', value: 'high' },
+        ];
+        for (const check of checks) {
+            try {
+                if (fs.existsSync(check.path)) {
+                    discovered.push({
+                        category: check.category,
+                        name: check.name,
+                        evidence: check.path.replace(home, '~'),
+                        value: check.value,
+                    });
+                }
+            }
+            catch {
+                // Skip inaccessible paths
+            }
+        }
+    }
+    if (scope === 'config' || scope === 'both') {
+        // Check environment for known tool/API integrations
+        const envChecks = [
+            { env: 'OPENAI_API_KEY', category: 'AI/ML', name: 'OpenAI API Integration', value: 'high' },
+            { env: 'ANTHROPIC_API_KEY', category: 'AI/ML', name: 'Anthropic Claude Integration', value: 'high' },
+            { env: 'SOLANA_RPC_URL', category: 'Blockchain', name: 'Solana On-Chain Access', value: 'high' },
+            { env: 'AGENTKEYS_API_KEY', category: 'AgentKeys', name: 'AgentKeys Marketplace Agent', value: 'medium' },
+            { env: 'GITHUB_TOKEN', category: 'Development', name: 'GitHub Automation', value: 'medium' },
+            { env: 'DATABASE_URL', category: 'Infrastructure', name: 'Database Access Layer', value: 'medium' },
+            { env: 'REDIS_URL', category: 'Infrastructure', name: 'Cache/Queue Management', value: 'low' },
+            { env: 'STRIPE_SECRET_KEY', category: 'Payments', name: 'Stripe Payment Processing', value: 'high' },
+            { env: 'TWITTER_API_KEY', category: 'Social', name: 'Twitter/X API Integration', value: 'medium' },
+            { env: 'DISCORD_TOKEN', category: 'Social', name: 'Discord Bot Automation', value: 'medium' },
+            { env: 'TELEGRAM_BOT_TOKEN', category: 'Social', name: 'Telegram Bot Integration', value: 'medium' },
+            { env: 'AWS_ACCESS_KEY_ID', category: 'Cloud', name: 'AWS Cloud Services', value: 'high' },
+            { env: 'GOOGLE_APPLICATION_CREDENTIALS', category: 'Cloud', name: 'Google Cloud Integration', value: 'high' },
+        ];
+        for (const check of envChecks) {
+            if (process.env[check.env]) {
+                // Only record that it exists — never log the value
+                discovered.push({
+                    category: check.category,
+                    name: check.name,
+                    evidence: `$${check.env} is set`,
+                    value: check.value,
+                });
+            }
+        }
+    }
+    // ── Generate report ───────────────────────────────────────────────────────
+    // Deduplicate by name
+    const unique = discovered.filter((d, i, arr) => arr.findIndex(x => x.name === d.name) === i);
+    // Group into recommended pack bundles by category
+    const byCategory = {};
+    for (const item of unique) {
+        if (!byCategory[item.category])
+            byCategory[item.category] = [];
+        byCategory[item.category].push(item);
+    }
+    const highValueCount = unique.filter(u => u.value === 'high').length;
+    const estimatedRevenue = highValueCount * 2.5 + unique.filter(u => u.value === 'medium').length * 0.8;
+    if (opts.json) {
+        console.log(JSON.stringify({
+            success: true,
+            data: {
+                scope,
+                skills_found: unique.length,
+                high_value: highValueCount,
+                categories: byCategory,
+                estimated_monthly_revenue_sol: estimatedRevenue.toFixed(2),
+            },
+        }));
+        return;
+    }
+    console.log();
+    console.log('  ── GotSkills? Audit Results ──────────────────────');
+    console.log();
+    if (unique.length === 0) {
+        console.log('  No capabilities detected in the scanned scope.');
+        console.log('  Try scanning more: agentkeys got-skills --scan both');
+        return;
+    }
+    console.log(`  Found ${unique.length} potential skill${unique.length !== 1 ? 's' : ''} across ${Object.keys(byCategory).length} categories.`);
+    console.log();
+    // Display by category
+    for (const [category, skills] of Object.entries(byCategory)) {
+        console.log(`  ▸ ${category}`);
+        for (const skill of skills) {
+            const badge = skill.value === 'high' ? '🔥' : skill.value === 'medium' ? '⚡' : '○';
+            console.log(`    ${badge} ${skill.name}`);
+            console.log(`       Evidence: ${skill.evidence}`);
+        }
+        console.log();
+    }
+    // Recommended pack bundles
+    console.log('  ── Recommended Pack Groupings ────────────────────');
+    console.log();
+    let packNum = 1;
+    for (const [category, skills] of Object.entries(byCategory)) {
+        if (skills.length > 0) {
+            const suggestedName = `${category} Agent Pack`;
+            const highVal = skills.filter(s => s.value === 'high').length;
+            const suggestedPrice = highVal >= 2 ? '1.5' : highVal === 1 ? '0.8' : '0.3';
+            console.log(`  Pack ${packNum}: "${suggestedName}"`);
+            console.log(`    Skills: ${skills.map(s => s.name).join(', ')}`);
+            console.log(`    Suggested price: ${suggestedPrice} SOL`);
+            console.log(`    Create: agentkeys pack-create`);
+            console.log();
+            packNum++;
+        }
+    }
+    // Revenue estimate
+    console.log('  ── Revenue Estimate ──────────────────────────────');
+    console.log();
+    console.log(`  If you listed all ${unique.length} skills and averaged 5 sales/month:`);
+    console.log(`  ~${estimatedRevenue.toFixed(2)} SOL/month (rough estimate)`);
+    console.log();
+    if (highValueCount > 0) {
+        console.log(`  🔥 ${highValueCount} high-value skill${highValueCount !== 1 ? 's' : ''} detected — you could be leaving money on the table.`);
+        console.log();
+    }
+    console.log('  ── Next Steps ────────────────────────────────────');
+    console.log();
+    console.log('  1. agentkeys pack-create         — create a new skill pack');
+    console.log('  2. agentkeys pack-add-skill      — add skills to your pack');
+    console.log('  3. agentkeys pack-publish        — publish and set price');
+    console.log('  4. agentkeys market-my-listings  — view your live listings');
+    console.log();
+    console.log('  Nothing was saved. Run again anytime.');
+    console.log();
+});
+// ─── Setup ───────────────────────────────────────────────────────────────────
+// OKX Agentic Wallet setup — guides through the full 4-step flow.
+program
+    .command('setup')
+    .description('Set up your AgentKeys identity and OKX Agentic Wallet (TEE-protected, no seed phrase)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const hasApiKey = !!process.env.AGENTKEYS_API_KEY;
+    if (!opts.json) {
+        console.log();
+        console.log('  ── AgentKeys Setup ───────────────────────────────');
+        console.log();
+    }
+    if (!hasApiKey) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                success: false,
+                error: {
+                    code: 'NO_API_KEY',
+                    message: 'AGENTKEYS_API_KEY is not set. Register at agentkeys.app, then set the env var.',
+                    next_steps: [
+                        'Register at https://agentkeys.app or via POST /api/agents/register',
+                        'Set: export AGENTKEYS_API_KEY=<your-key>',
+                        'Run: agentkeys wallet-setup --email <your@email.com>',
+                    ],
+                },
+            }));
+        }
+        else {
+            console.log('  Step 1: Get your agent API key');
+            console.log();
+            console.log('  Register at: https://agentkeys.app');
+            console.log("  Or via API:  POST /api/agents/register { name: 'YourAgent' }");
+            console.log();
+            console.log('  Then set:  export AGENTKEYS_API_KEY=<your-key>');
+            console.log();
+            console.log('  Once you have your API key, run:');
+            console.log('    agentkeys wallet-setup --email <your@email.com>');
+            console.log();
+        }
+        return;
+    }
+    const profileResult = await apiFetch('/api/agents/me', { method: 'GET' });
+    if (!profileResult.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: profileResult.error }));
+        }
+        else {
+            console.error(`✗ ${profileResult.error?.message ?? 'Failed to fetch profile'}`);
+        }
+        process.exit(1);
+    }
+    const walletConfigured = profileResult.data?.wallet_configured ?? false;
+    const walletAddress = profileResult.data?.wallet_address ?? null;
+    if (walletConfigured && walletAddress) {
+        if (opts.json) {
+            console.log(JSON.stringify({
+                success: true,
+                data: {
+                    wallet_configured: true,
+                    wallet_address: walletAddress,
+                    message: 'Already set up. Your OKX Agentic Wallet is active.',
+                },
+            }));
+        }
+        else {
+            console.log('  ✓ Already set up!');
+            console.log();
+            console.log(`  Wallet: ${walletAddress}`);
+            console.log();
+            console.log('  ── Commands ──────────────────────────────────────');
+            console.log('  agentkeys wallet                  — view balance');
+            console.log('  agentkeys verify-start twitter    — identity verification');
+            console.log('  agentkeys pack-create             — build your first pack');
+            console.log();
+        }
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            success: true,
+            data: {
+                wallet_configured: false,
+                message: 'Wallet not yet configured.',
+                next_steps: [
+                    'Run: agentkeys wallet-setup --email <your@email.com>',
+                    'Then: agentkeys wallet-setup-verify --email <email> --otp <code>',
+                ],
+            },
+        }));
+    }
+    else {
+        console.log('  ── Step 2: Create your OKX Agentic Wallet ────────');
+        console.log();
+        console.log('  Your wallet is TEE-protected — no seed phrase, no private key exposure.');
+        console.log();
+        console.log('  Run:  agentkeys wallet-setup --email <your@email.com>');
+        console.log('  Then: agentkeys wallet-setup-verify --email <email> --otp <code>');
+        console.log();
+        console.log('  ── What is OKX Agentic Wallet? ───────────────────');
+        console.log('  Private keys are generated and stored inside OKX TEE.');
+        console.log('  No one — not you, not OKX, not the platform — can extract them.');
+        console.log('  Your wallet is bound to your email, recoverable via OTP.');
+        console.log();
+    }
+});
+// ─── Register ───────────────────────────────────────────────────────────────
+program
+    .command('register')
+    .description('Register a new agent and get your API key')
+    .requiredOption('--name <name>', 'Agent name')
+    .option('--bio <bio>', 'Optional agent bio')
+    .option('--keypair <path>', 'Path to Solana keypair JSON file (array of bytes). If omitted, a new keypair is generated and saved to ~/.agentkeys/keypair.json')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+    const os = await Promise.resolve().then(() => __importStar(require('os')));
+    const path = await Promise.resolve().then(() => __importStar(require('path')));
+    const nacl = await Promise.resolve().then(() => __importStar(require('tweetnacl')));
+    // Load or auto-generate keypair
+    let keypairBytes;
+    let keypairPath = null;
+    if (opts.keypair) {
+        // Load from provided path
+        try {
+            const raw = fs.readFileSync(opts.keypair, 'utf-8');
+            const arr = JSON.parse(raw);
+            keypairBytes = new Uint8Array(arr);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (opts.json) {
+                console.log(JSON.stringify({ success: false, error: { code: 'KEYPAIR_LOAD_FAILED', message: msg } }));
+            }
+            else {
+                console.error(`✗ Failed to load keypair from ${opts.keypair}: ${msg}`);
+            }
+            process.exit(1);
+        }
+    }
+    else {
+        // Auto-generate a new Ed25519 keypair and persist it
+        const defaultDir = path.join(os.homedir(), '.agentkeys');
+        keypairPath = path.join(defaultDir, 'keypair.json');
+        if (fs.existsSync(keypairPath)) {
+            // Reuse existing auto-generated keypair
+            try {
+                const raw = fs.readFileSync(keypairPath, 'utf-8');
+                const arr = JSON.parse(raw);
+                keypairBytes = new Uint8Array(arr);
+                if (!opts.json)
+                    console.log(`  ℹ️  Using existing keypair at ${keypairPath}`);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (opts.json) {
+                    console.log(JSON.stringify({ success: false, error: { code: 'KEYPAIR_LOAD_FAILED', message: msg } }));
+                }
+                else {
+                    console.error(`✗ Failed to load existing keypair from ${keypairPath}: ${msg}`);
+                }
+                process.exit(1);
+            }
+        }
+        else {
+            // Generate fresh keypair
+            const kp = nacl.default.sign.keyPair();
+            keypairBytes = kp.secretKey; // 64 bytes
+            try {
+                fs.mkdirSync(defaultDir, { recursive: true });
+                fs.writeFileSync(keypairPath, JSON.stringify(Array.from(keypairBytes)), { mode: 0o600 });
+                if (!opts.json)
+                    console.log(`  ✓ Generated new keypair → ${keypairPath}`);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (opts.json) {
+                    console.log(JSON.stringify({ success: false, error: { code: 'KEYPAIR_SAVE_FAILED', message: msg } }));
+                }
+                else {
+                    console.error(`✗ Failed to save keypair: ${msg}`);
+                }
+                process.exit(1);
+            }
+        }
+    }
+    // Build Keypair + message
+    const bs58Mod = await Promise.resolve().then(() => __importStar(require('bs58')));
+    const bs58Encode = bs58Mod.default?.encode ?? bs58Mod.encode;
+    const secretKey = keypairBytes.slice(0, 64);
+    const publicKeyBytes = keypairBytes.slice(32, 64);
+    const pubkey = bs58Encode(publicKeyBytes);
+    const timestamp = Date.now().toString();
+    const cryptoMod = await Promise.resolve().then(() => __importStar(require('crypto')));
+    const nonce = cryptoMod.randomBytes(4).toString('hex');
+    const message = `AgentKeys registration\nWallet: ${pubkey}\nTimestamp: ${timestamp}\nNonce: ${nonce}`;
+    const msgBytes = new TextEncoder().encode(message);
+    const sigBytes = nacl.default.sign.detached(msgBytes, secretKey);
+    const signature = bs58Encode(sigBytes);
+    // POST to register (no API key needed)
+    const baseUrl = process.env.AGENTKEYS_API_URL ?? 'https://agentkeys.vercel.app';
+    const body = {
+        wallet_address: pubkey,
+        signature,
+        message,
+        name: opts.name,
+    };
+    if (opts.bio)
+        body.bio = opts.bio;
+    let res;
+    try {
+        res = await fetch(`${baseUrl}/api/agents/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'NETWORK_ERROR', message: msg } }));
+        }
+        else {
+            console.error(`✗ Network error: ${msg}`);
+        }
+        process.exit(1);
+    }
+    const json = await res.json();
+    if (!res.ok) {
+        const errMsg = (json.error && typeof json.error === 'object' && 'message' in json.error)
+            ? json.error.message
+            : `HTTP ${res.status}`;
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'REGISTER_FAILED', message: errMsg } }));
+        }
+        else {
+            console.error(`✗ Registration failed (${res.status}): ${errMsg}`);
+        }
+        process.exit(1);
+    }
+    const agent = json.data?.agent;
+    const apiKey = json.data?.api_key;
+    if (!agent || !apiKey) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'UNEXPECTED_RESPONSE', message: 'Missing agent or api_key in response' } }));
+        }
+        else {
+            console.error('✗ Unexpected response from server');
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: { id: agent.id, api_key: apiKey, name: agent.name } }));
+    }
+    else {
+        console.log();
+        console.log('  ✓ Agent registered successfully!');
+        console.log();
+        console.log(`  Name:     ${agent.name}`);
+        console.log(`  Agent ID: ${agent.id}`);
+        console.log();
+        console.log('  ┌─────────────────────────────────────────────────┐');
+        console.log('  │  🔑 YOUR API KEY — SAVE THIS NOW                │');
+        console.log('  │                                                 │');
+        console.log(`  │  ${apiKey.padEnd(47)} │`);
+        console.log('  │                                                 │');
+        console.log('  │  ⚠️  This will NOT be shown again.              │');
+        console.log('  └─────────────────────────────────────────────────┘');
+        console.log();
+        console.log(`  export AGENTKEYS_API_KEY=${apiKey}`);
+        console.log();
+        console.log('  Next steps:');
+        console.log('    agentkeys wallet-setup --email you@email.com');
+        console.log('    agentkeys wallet');
+        console.log();
+    }
+});
+// ─── Status ──────────────────────────────────────────────────────────────────
+program
+    .command('status')
+    .description('Check your agent status — wallet, verification, and packs')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const apiKey = process.env.AGENTKEYS_API_KEY ?? '';
+    if (!apiKey) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: { code: 'NO_API_KEY', message: 'AGENTKEYS_API_KEY is not set' } }));
+        }
+        else {
+            console.error('✗ AGENTKEYS_API_KEY is not set.');
+            console.error('  Register at: agentkeys.vercel.app');
+            console.error('  Then: export AGENTKEYS_API_KEY=<your-key>');
+        }
+        process.exit(3);
+    }
+    const result = await apiFetch('/api/agents/me');
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch agent status'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const agent = result.data;
+    const walletAddr = agent.wallet_address;
+    const walletDisplay = walletAddr
+        ? `✓ ${walletAddr.slice(0, 8)}...${walletAddr.slice(-4)}`
+        : '✗ not configured';
+    const verified = agent.verification_status === 'verified';
+    const baseUrl = process.env.AGENTKEYS_API_URL ?? 'https://agentkeys.vercel.app';
+    console.log();
+    console.log('  ── Agent Status ──────────────────────────────────');
+    console.log(`  Name:         ${agent.name}`);
+    console.log(`  ID:           ${agent.id}`);
+    console.log(`  Wallet:       ${walletDisplay}`);
+    console.log(`  Verified:     ${verified ? '✓' : '✗ unverified'}`);
+    console.log(`  Creator:      ${agent.is_active_creator ? '✓ active' : '✗ inactive'}`);
+    console.log('  ─────────────────────────────────────────────────');
+    console.log(`  API URL:      ${baseUrl}`);
+    console.log();
+    if (!walletAddr) {
+        console.log('  → Run: agentkeys wallet-setup --email <you@email.com>');
+    }
+    else if (!verified) {
+        console.log('  → Run: agentkeys verify-start twitter <your-handle>');
+    }
+    else {
+        console.log('  Ready. Run: agentkeys pack-create');
+    }
+    console.log();
+});
+// ─── Pack List ────────────────────────────────────────────────────────────────
+program
+    .command('pack-list')
+    .description('List your skill packs')
+    .option('--limit <n>', 'Max results', '20')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    const limit = parseInt(opts.limit ?? '20', 10);
+    const result = await apiFetch(`/api/skill-sets?limit=${limit}`);
+    if (!result.ok) {
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to fetch packs'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const packs = Array.isArray(result.data) ? result.data : [];
+    if (packs.length === 0) {
+        console.log();
+        console.log('  No packs yet.');
+        console.log('  Create one: agentkeys pack-create');
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(`  Your Packs (${packs.length})`);
+    console.log('  ─────────────────────────────────────────────────────────────');
+    packs.forEach((pack, i) => {
+        const status = pack.is_published ? 'Published' : 'Draft';
+        const supply = pack.supply_cap != null ? `${pack.copies_minted ?? 0}/${pack.supply_cap}` : '—';
+        const price = pack.price_sol != null ? `${pack.price_sol} SOL` : '—';
+        const tier = (pack.rarity_tier ?? '—').padEnd(10, ' ');
+        const name = (pack.name ?? pack.id).padEnd(30, ' ');
+        const shortId = pack.id.slice(0, 8) + '…';
+        console.log(`  ${String(i + 1).padStart(2)}. ${name}  [${status}]  ${tier}  ${pack.power_level ?? 0} skills  ${supply} minted  ${price}`);
+        console.log(`      ID: ${shortId}`);
+    });
+    console.log();
+});
+// ─── Skill Create ─────────────────────────────────────────────────────────────
+program
+    .command('skill-create')
+    .description('Create a new skill')
+    .option('--name <name>', 'Skill name (skip prompt)')
+    .option('--slug <slug>', 'Skill slug (auto-generated if omitted)')
+    .option('--description <desc>', 'Skill description (skip prompt)')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+    let name = opts.name;
+    let slug = opts.slug;
+    let description = opts.description;
+    if (!name) {
+        name = await prompt('Skill name: ');
+        if (!name?.trim()) {
+            console.error('✗ Skill name is required.');
+            process.exit(1);
+        }
+        name = name.trim();
+    }
+    const autoSlug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    if (!slug) {
+        const inputSlug = await prompt(`Slug (default: ${autoSlug}): `);
+        slug = inputSlug.trim() || autoSlug;
+    }
+    if (!description) {
+        const inputDesc = await prompt('Description (optional, press Enter to skip): ');
+        description = inputDesc.trim() || undefined;
+    }
+    const body = { name, slug };
+    if (description)
+        body.description = description;
+    // content_md is optional — API will generate a placeholder if omitted
+    const result = await apiFetch('/api/skills', { method: 'POST', body: JSON.stringify(body) });
+    if (!result.ok) {
+        const code = result.error?.code;
+        if (opts.json) {
+            console.log(JSON.stringify({ success: false, error: result.error }));
+        }
+        else if (result.status === 409 || code === 'CONFLICT') {
+            console.error(`✗ Slug "${slug}" is already taken.`);
+            console.error(`  Try: agentkeys skill-create --slug ${slug}-2`);
+        }
+        else if (result.status === 403 || code === 'VERIFICATION_REQUIRED') {
+            console.error('✗ Verification required to create skills.');
+            console.error('  Run: agentkeys verify-start twitter <your-handle>');
+        }
+        else {
+            console.error(`✗ ${result.error?.message ?? 'Failed to create skill'}`);
+        }
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ success: true, data: result.data }));
+        return;
+    }
+    const skill = result.data;
+    console.log(`✓ Skill created: ${skill.name}`);
+    console.log(`  ID:   ${skill.id}`);
+    console.log(`  Slug: ${skill.slug}`);
+    console.log();
+    console.log('Next steps:');
+    console.log(`  Add to a pack: agentkeys pack-add-skill <pack-id> ${skill.id}`);
+    console.log(`  View packs:    agentkeys pack-list`);
+});
+program.parse(process.argv);
+//# sourceMappingURL=agentkeys.js.map