@palmyr/cli 1.5.6 → 1.7.0

package/dist/cli.js

@@ -213,13 +213,35 @@ function subcommandHelp(command, subcommand, options) {
 const WALLET_HELP = {
     create: [
         { flag: '--name <name>', desc: 'Wallet name', hint: 'default: "My Wallet"' },
-        { flag: '--managed', desc: 'Create managed wallet with human oversight via passkey' },
-        { flag: '--chains <list>', desc: 'Supported chains (comma-separated)', hint: 'default: solana,evm' },
+        { flag: '--managed', desc: 'Create managed wallet with human oversight via passkey (single-create only)' },
+        { flag: '--solana', desc: 'Materialize the Solana account only', hint: 'default: both chains' },
+        { flag: '--base', desc: 'Materialize the Base/EVM account only', hint: 'pair with --solana for both (default)' },
+        { flag: '--tag <name>', desc: 'Folder-like grouping tag', hint: 'e.g. palmyr-demo — required with --count' },
+        { flag: '--count <N>', desc: 'Bulk-create N wallets in one call (1-500)', hint: 'unmanaged only; requires --tag' },
+        { flag: '--name-prefix <p>', desc: 'Bulk name prefix; suffixed `-001..-N`', hint: 'default: same as --tag' },
     ],
     import: [
         { flag: '--mnemonic <words>', desc: 'BIP-39 mnemonic phrase (required)' },
         { flag: '--name <name>', desc: 'Wallet name', hint: 'default: "Imported Wallet"' },
         { flag: '--managed', desc: 'Import as managed wallet' },
+        { flag: '--solana', desc: 'Materialize the Solana account only' },
+        { flag: '--base', desc: 'Materialize the Base/EVM account only' },
+        { flag: '--tag <name>', desc: 'Assign a tag at import time' },
+    ],
+    tags: [
+        { flag: '(no args)', desc: 'List all tags with wallet count, chains, and date range' },
+    ],
+    tag: [
+        { flag: '<WALLET_ID>', desc: 'Wallet id or name (positional or --id)' },
+        { flag: '<TAG>', desc: 'Tag to assign (positional)' },
+        { flag: '--clear', desc: 'Remove the tag from this wallet instead of assigning one' },
+    ],
+    'tag-delete': [
+        { flag: '<TAG>', desc: 'Tag to wipe (positional)' },
+        { flag: '--confirm', desc: 'Required — deletes every wallet sharing this tag (irreversible)' },
+    ],
+    list: [
+        { flag: '--tag <name>', desc: 'Filter to wallets in this tag' },
     ],
     'sign-message': [
         { flag: '<WALLET_ID>', desc: 'Wallet ID (positional or --id)' },
@@ -355,6 +377,327 @@ const WALLET_HELP = {
         { flag: '--dst-decimals <n>', desc: 'Dest token decimals', hint: 'default 6 (USDC-like)' },
     ],
 };
+const PHONE_HELP = {
+    search: [
+        { flag: '--country <ISO>', desc: 'Country code', hint: 'default US (e.g. US, GB, AE)' },
+        { flag: '--limit <N>', desc: 'Max results to return' },
+        { flag: '(price)', desc: 'Free — no payment required' },
+        { flag: '(example)', desc: 'palmyr phone search --country US --json' },
+    ],
+    buy: [
+        { flag: '--country <ISO>', desc: 'Country code (required)', hint: 'e.g. US, GB' },
+        { flag: '--area <code>', desc: 'Preferred area code (optional, US only)' },
+        { flag: '(price)', desc: '$3.00 per number provisioned' },
+        { flag: '(example)', desc: 'palmyr phone buy --country US' },
+    ],
+    sms: [
+        { flag: '--id <PHONE_ID>', desc: 'Source phone number id (required)' },
+        { flag: '--to <+E.164>', desc: 'Destination phone number (required)', hint: 'e.g. +15551234567' },
+        { flag: '--body <text>', desc: 'Message body (required)' },
+        { flag: '(price)', desc: '$0.05 per SMS sent' },
+        { flag: '(example)', desc: 'palmyr phone sms --id PN_abc --to +15551234567 --body "hi"' },
+    ],
+    call: [
+        { flag: '--id <PHONE_ID>', desc: 'Source phone number id (required)' },
+        { flag: '--to <+E.164>', desc: 'Destination phone number (required)' },
+        { flag: '--tts <text>', desc: 'Text-to-speech to play on answer (optional)' },
+        { flag: '(price)', desc: '$0.10 per call placed' },
+        { flag: '(example)', desc: 'palmyr phone call --id PN_abc --to +15551234567 --tts "hello"' },
+    ],
+    list: [
+        { flag: '(no args)', desc: 'List phone numbers owned by your wallet' },
+        { flag: '(price)', desc: '$0.01 per call' },
+        { flag: '(example)', desc: 'palmyr phone list --json' },
+    ],
+    messages: [
+        { flag: '--id <PHONE_ID>', desc: 'Phone number id to read SMS for (required; positional also accepted)' },
+        { flag: '(price)', desc: '$0.02 per call' },
+        { flag: '(example)', desc: 'palmyr phone messages --id PN_abc' },
+    ],
+    calls: [
+        { flag: '--id <PHONE_ID>', desc: 'Phone number id to list calls for (required; positional also accepted)' },
+        { flag: '(price)', desc: '$0.02 per call' },
+        { flag: '(example)', desc: 'palmyr phone calls --id PN_abc' },
+    ],
+    release: [
+        { flag: '--id <PHONE_ID>', desc: 'Phone number id to release (required; positional also accepted)' },
+        { flag: '(price)', desc: '$0.01 per release (stops monthly Telnyx billing)' },
+        { flag: '(example)', desc: 'palmyr phone release --id PN_abc' },
+    ],
+    'call-info': [
+        { flag: '--call <CALL_ID>', desc: 'Call control id (required; --id and positional also accepted)' },
+        { flag: '(price)', desc: '$0.02 per lookup' },
+        { flag: '(example)', desc: 'palmyr phone call-info --call CC_abc' },
+    ],
+    speak: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '--text <text>', desc: 'TTS text to speak (required; --tts alias accepted)' },
+        { flag: '--voice <name>', desc: 'TTS voice (optional, provider default otherwise)' },
+        { flag: '--language <code>', desc: 'TTS language code (optional, e.g. en-US)' },
+        { flag: '(price)', desc: '$0.08 per speak action' },
+        { flag: '(example)', desc: 'palmyr phone speak --call CC_abc --text "please hold"' },
+    ],
+    play: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '--url <audio_url>', desc: 'Public audio URL to play (required; --audio-url alias accepted)' },
+        { flag: '(price)', desc: '$0.08 per playback' },
+        { flag: '(example)', desc: 'palmyr phone play --call CC_abc --url https://example.com/hold.mp3' },
+    ],
+    dtmf: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '--digits <seq>', desc: 'DTMF digit sequence (required; positional also accepted)', hint: 'e.g. "1234#"' },
+        { flag: '(price)', desc: '$0.02 per DTMF send' },
+        { flag: '(example)', desc: 'palmyr phone dtmf --call CC_abc --digits "1234#"' },
+    ],
+    gather: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '--min-digits <N>', desc: 'Minimum digits to collect (optional)' },
+        { flag: '--max-digits <N>', desc: 'Maximum digits to collect (optional)' },
+        { flag: '--timeout <ms>', desc: 'Per-input timeout in milliseconds (optional)' },
+        { flag: '--terminating-digit <d>', desc: 'Digit that ends collection (optional, e.g. "#")' },
+        { flag: '--prompt <text>', desc: 'Optional TTS prompt to play before gathering' },
+        { flag: '--prompt-voice <name>', desc: 'TTS voice for the prompt (optional)' },
+        { flag: '(price)', desc: '$0.08 per gather action' },
+        { flag: '(example)', desc: 'palmyr phone gather --call CC_abc --max-digits 4 --terminating-digit "#" --prompt "Enter PIN"' },
+    ],
+    record: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '--format <fmt>', desc: 'Recording format (optional, provider default otherwise)' },
+        { flag: '(price)', desc: '$0.10 per record start' },
+        { flag: '(example)', desc: 'palmyr phone record --call CC_abc --format mp3' },
+    ],
+    'record-stop': [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '(price)', desc: '$0.02 per stop' },
+        { flag: '(example)', desc: 'palmyr phone record-stop --call CC_abc' },
+    ],
+    hangup: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '(price)', desc: '$0.02 per hangup' },
+        { flag: '(example)', desc: 'palmyr phone hangup --call CC_abc' },
+    ],
+    answer: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of an inbound call (required)' },
+        { flag: '(price)', desc: '$0.02 per answer' },
+        { flag: '(example)', desc: 'palmyr phone answer --call CC_abc' },
+    ],
+    transfer: [
+        { flag: '--call <CALL_ID>', desc: 'Call control id of a live call (required)' },
+        { flag: '--to <+E.164>', desc: 'Destination phone number to bridge into (required)' },
+        { flag: '(price)', desc: '$0.10 per transfer' },
+        { flag: '(example)', desc: 'palmyr phone transfer --call CC_abc --to +15557654321' },
+    ],
+};
+const EMAIL_HELP = {
+    create: [
+        { flag: '--name <name>', desc: 'Inbox name (required)' },
+        { flag: '--domain <domain>', desc: 'Wallet-owned domain to host the inbox on (optional)', hint: 'default: Palmyr-hosted domain' },
+        { flag: '--wallet <id|name>', desc: 'Wallet to own the inbox (optional)' },
+        { flag: '(price)', desc: '$2.00 per inbox provisioned' },
+        { flag: '(example)', desc: 'palmyr email create --name agent --domain example.com' },
+    ],
+    list: [
+        { flag: '(no args)', desc: 'List inboxes owned by your wallet' },
+        { flag: '(price)', desc: '$0.01 per call' },
+        { flag: '(example)', desc: 'palmyr email list --json' },
+    ],
+    status: [
+        { flag: '<domain>', desc: 'Domain to check (positional or --domain)', hint: 'e.g. example.com' },
+        { flag: '(price)', desc: '$0.01 per call' },
+        { flag: '(example)', desc: 'palmyr email status example.com' },
+    ],
+    register: [
+        { flag: '<domain>', desc: 'Wallet-owned domain to (re-)register with Mailgun (positional or --domain)' },
+        { flag: '(price)', desc: '$0.05 per registration' },
+        { flag: '(example)', desc: 'palmyr email register example.com' },
+    ],
+    read: [
+        { flag: '--id <INBOX_ID>', desc: 'Inbox id (required; positional also accepted)' },
+        { flag: '(price)', desc: '$0.02 per call' },
+        { flag: '(example)', desc: 'palmyr email read --id INB_abc123' },
+    ],
+    send: [
+        { flag: '--id <INBOX_ID>', desc: 'Source inbox id (required)' },
+        { flag: '--to <addr>', desc: 'Destination email (required)' },
+        { flag: '--subject <text>', desc: 'Subject line (required)' },
+        { flag: '--body <text>', desc: 'Message body (required)' },
+        { flag: '(price)', desc: '$0.08 per email sent' },
+        { flag: '(example)', desc: 'palmyr email send --id INB_abc --to user@x.com --subject Hi --body "..."' },
+    ],
+    threads: [
+        { flag: '--id <INBOX_ID>', desc: 'Inbox id (required; positional also accepted)' },
+        { flag: '(price)', desc: '$0.02 per call' },
+        { flag: '(example)', desc: 'palmyr email threads --id INB_abc123' },
+    ],
+};
+const COMPUTE_HELP = {
+    plans: [
+        { flag: '--location <loc>', desc: 'Filter to types deployable in this datacenter (optional)', hint: 'e.g. fsn1, nbg1, hel1, ash, hil' },
+        { flag: '(price)', desc: 'Free — live discovery from Hetzner' },
+        { flag: '(example)', desc: 'palmyr compute plans --location fsn1 --json' },
+    ],
+    locations: [
+        { flag: '(no args)', desc: 'List Hetzner datacenters + per-location server-type availability' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'install-recipes': [
+        { flag: '(no args)', desc: 'List available agent install recipes (hermes, openclaw, …)' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'ssh-key': [
+        { flag: 'add <pubkey-file>', desc: 'Upload a key to Hetzner', hint: '[--name "label"]' },
+        { flag: 'list', desc: 'List uploaded Hetzner SSH keys' },
+        { flag: 'delete <id>', desc: 'Remove a Hetzner SSH key' },
+        { flag: '(price)', desc: 'add $0.10 · list $0.01 · delete $0.01' },
+    ],
+    deploy: [
+        { flag: '--type <name>', desc: 'Hetzner server type', hint: 'default cx23' },
+        { flag: '--name <name>', desc: 'Server name', hint: 'default agent-<timestamp>' },
+        { flag: '--location <loc>', desc: 'Hetzner datacenter (optional)', hint: 'e.g. fsn1, nbg1' },
+        { flag: '--install <recipes>', desc: 'Comma-separated install recipes', hint: 'e.g. hermes,openclaw' },
+        { flag: '--no-install', desc: 'Skip cloud-init entirely (vanilla Ubuntu)' },
+        { flag: '--generate-ssh-key', desc: 'GOLDEN PATH (default): generate a fresh keypair locally' },
+        { flag: '--pubkey-file <path>', desc: 'Use an existing public key from disk' },
+        { flag: '--pubkey "ssh-..."', desc: 'Use an inline public key string' },
+        { flag: '--ssh-key <id>', desc: 'Numeric Hetzner key id (already uploaded)' },
+        { flag: '--no-wait', desc: 'Return immediately instead of waiting for SSH-ready' },
+        { flag: '--wait-timeout <s>', desc: 'Override readiness timeout (30–900s)' },
+        { flag: '(price)', desc: '$6.00 per deploy (Hetzner billing flows through)' },
+        { flag: '(example)', desc: 'palmyr compute deploy --type cx23 --install hermes' },
+    ],
+    wait: [
+        { flag: '<name|id>', desc: 'Server (positional, name or numeric id)' },
+        { flag: '--install <recipes>', desc: 'Also gate on the install marker file (e.g. hermes)' },
+        { flag: '--key <path>', desc: 'Path to the private key for SSH verification' },
+        { flag: '--wait-timeout <s>', desc: 'Override readiness timeout (30–900s)' },
+        { flag: '(price)', desc: '$0.01 per readiness poll (server status check)' },
+        { flag: '(example)', desc: 'palmyr compute wait my-vps --install hermes' },
+    ],
+    ssh: [
+        { flag: '<name|id>', desc: 'Server (positional)' },
+        { flag: '(price)', desc: 'Free — local cache lookup only' },
+        { flag: '(example)', desc: 'palmyr compute ssh my-vps' },
+    ],
+    exec: [
+        { flag: '<name|id> -- <cmd> [args...]', desc: 'Run a one-shot command via Palmyr SSH bridge' },
+        { flag: '--timeout <s>', desc: 'Command timeout (1–120s)' },
+        { flag: '(price)', desc: '$0.05 per command' },
+        { flag: '(example)', desc: 'palmyr compute exec my-vps -- systemctl status openclaw' },
+    ],
+    rename: [
+        { flag: '<name|id> <new-name>', desc: 'Rename server (metadata-only, no reboot)' },
+        { flag: '(price)', desc: '$0.01 per rename' },
+    ],
+    'reset-password': [
+        { flag: '<name|id>', desc: 'Rotate the root password (Hetzner-side)' },
+        { flag: '(price)', desc: '$0.10 per action' },
+    ],
+    console: [
+        { flag: '<name|id>', desc: 'Get a noVNC console URL (break-glass)' },
+        { flag: '(price)', desc: '$0.10 per action' },
+    ],
+    reboot: [
+        { flag: '<name|id>', desc: 'Reboot the server' },
+        { flag: '(price)', desc: '$0.10 per action' },
+    ],
+    'setup-ssh': [
+        { flag: '--id <SERVER_ID>', desc: 'Server id (required; positional also accepted)' },
+        { flag: '--pubkey-file <path>', desc: 'Public key file to inject' },
+        { flag: '--pubkey "ssh-..."', desc: 'Inline public key string' },
+        { flag: '(price)', desc: '$0.01 per call' },
+        { flag: '(example)', desc: 'palmyr compute setup-ssh --id 12345 --pubkey-file ~/.ssh/id_ed25519.pub' },
+    ],
+    list: [
+        { flag: '(no args)', desc: 'List your deployed servers' },
+        { flag: '(price)', desc: '$0.01 per call' },
+    ],
+    delete: [
+        { flag: '--id <SERVER_ID>', desc: 'Server id (required; positional also accepted)' },
+        { flag: '(price)', desc: '$0.10 per deletion (Hetzner billing stops on confirm)' },
+    ],
+};
+const DOMAIN_HELP = {
+    check: [
+        { flag: '--name <domain>', desc: 'Domain or root name (positional also accepted)' },
+        { flag: '(price)', desc: 'Free — availability lookup only' },
+        { flag: '(example)', desc: 'palmyr domain check example.dev' },
+    ],
+    pricing: [
+        { flag: '--name <root>', desc: 'Root name to price across TLDs (positional also accepted)' },
+        { flag: '(price)', desc: 'Free' },
+        { flag: '(example)', desc: 'palmyr domain pricing example' },
+    ],
+    buy: [
+        { flag: '--name <domain>', desc: 'Fully-qualified domain (required, e.g. example.dev)' },
+        { flag: '(price)', desc: 'Dynamic — registrar cost × 1.25 markup (charged via x402)' },
+        { flag: '(example)', desc: 'palmyr domain buy --name example.dev' },
+    ],
+    list: [
+        { flag: '(no args)', desc: 'List domains owned or shared with your wallet' },
+        { flag: '(price)', desc: '$0.0001 ownership-proof micro-payment' },
+    ],
+    dns: [
+        { flag: '--name <domain>', desc: 'Domain to read DNS for (positional also accepted)' },
+        { flag: '(price)', desc: '$0.0001 ownership-proof micro-payment' },
+    ],
+    'transfer-ownership': [
+        { flag: '--name <domain>', desc: 'Domain to transfer (required)' },
+        { flag: '--to <wallet>', desc: 'Recipient wallet address (required)' },
+        { flag: '(price)', desc: '$0.0001 ownership-proof micro-payment' },
+    ],
+    share: [
+        { flag: '--name <domain>', desc: 'Domain to share (required)' },
+        { flag: '--with <wallet>', desc: 'Wallet to grant shared access (required)' },
+        { flag: '(price)', desc: '$0.0001 ownership-proof micro-payment' },
+    ],
+    unshare: [
+        { flag: '--name <domain>', desc: 'Domain to revoke from (required)' },
+        { flag: '--from <wallet>', desc: 'Wallet to revoke (required)' },
+        { flag: '(price)', desc: '$0.0001 ownership-proof micro-payment' },
+    ],
+};
+const CHAT_HELP = {
+    run: [
+        { flag: '"<intent>"', desc: 'Plain-string intent (positional or --intent)' },
+        { flag: '--budget <USDC>', desc: 'Max spend cap (required, positive USDC)' },
+        { flag: '--quality <q>', desc: 'Quality tier', hint: 'fast | cheap | best (default best)' },
+        { flag: '--execute', desc: 'Auto-execute the plan once generated' },
+        { flag: '--auto-approve-under <USDC>', desc: 'Skip approval prompts for steps cheaper than this' },
+        { flag: '(price)', desc: '$0.10 orchestration fee + sum of per-step costs (capped by --budget)' },
+        { flag: '(example)', desc: 'palmyr chat run "launch a sneaker brand" --budget 50' },
+    ],
+    resume: [
+        { flag: '<session_id>', desc: 'Existing session id (positional)' },
+        { flag: '"<follow-up>"', desc: 'Follow-up intent (positional remainder or --intent)' },
+        { flag: '--approve', desc: 'Approve a previously-generated plan' },
+        { flag: '--plan-id <id>', desc: 'Plan id to approve (pair with --approve)' },
+        { flag: '--budget <USDC>', desc: 'Override session budget (default $20)' },
+        { flag: '--execute', desc: 'Auto-execute the new plan' },
+        { flag: '(price)', desc: '$0.10 orchestration fee per new plan + per-step costs' },
+        { flag: '(example)', desc: 'palmyr chat resume sess_abc "now post 3 videos"' },
+    ],
+    status: [
+        { flag: '<session_id>', desc: 'Session id (positional)' },
+        { flag: '(price)', desc: 'Free — session inspection' },
+    ],
+    cancel: [
+        { flag: '<session_id>', desc: 'Session id (positional)' },
+        { flag: '(price)', desc: 'Free — halts execution and refunds remaining escrow' },
+    ],
+    sessions: [
+        { flag: '(no args)', desc: 'List your active i402 sessions' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    capabilities: [
+        { flag: '(no args)', desc: 'List canonical capability classes (e.g. web_search, mint_nft)' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    providers: [
+        { flag: '--capability <name>', desc: 'Filter providers by capability (optional)' },
+        { flag: '(price)', desc: 'Free' },
+        { flag: '(example)', desc: 'palmyr chat providers --capability web_search' },
+    ],
+};
 /**
  * Render a per-command menu (no subcommand given). On a TTY → Ink MenuScreen
  * with the Palmyr aesthetic. In agent mode → flat JSON listing the available
@@ -651,7 +994,7 @@ async function main() {
                 break;
             }
             case 'phone': {
-                if (!subcommand || flags.help) {
+                if (!subcommand || (flags.help && !PHONE_HELP[subcommand])) {
                     showMenu({
                         command: 'phone',
                         title: 'phone',
@@ -660,13 +1003,31 @@ async function main() {
                         commands: [
                             { name: 'search', description: 'Search available numbers', hint: '--country US' },
                             { name: 'buy', description: 'Buy a phone number', hint: '--country US' },
+                            { name: 'list', description: 'List numbers owned by your wallet' },
+                            { name: 'release', description: 'Release a phone number', hint: '--id PHONE_ID' },
                             { name: 'sms', description: 'Send an SMS', hint: '--id ID --to +1... --body "hi"' },
+                            { name: 'messages', description: 'Read SMS messages received on a number', hint: '--id PHONE_ID' },
                             { name: 'call', description: 'Place a voice call', hint: '--id ID --to +1... --tts "hello"' },
+                            { name: 'calls', description: 'List calls placed/received on a number', hint: '--id PHONE_ID' },
+                            { name: 'call-info', description: 'Get details on a single call', hint: '--call CALL_CONTROL_ID' },
+                            { name: 'speak', description: 'TTS into a live call', hint: '--call ID --text "..." [--voice V]' },
+                            { name: 'play', description: 'Play an audio URL into a live call', hint: '--call ID --url https://...' },
+                            { name: 'dtmf', description: 'Send DTMF tones to a live call', hint: '--call ID --digits "1234#"' },
+                            { name: 'gather', description: 'Collect DTMF input from caller', hint: '--call ID [--min-digits N --max-digits N --timeout MS --prompt "..."]' },
+                            { name: 'record', description: 'Start recording a live call', hint: '--call ID [--format mp3]' },
+                            { name: 'record-stop', description: 'Stop recording a live call', hint: '--call ID' },
+                            { name: 'hangup', description: 'End a live call', hint: '--call ID' },
+                            { name: 'answer', description: 'Answer an inbound call', hint: '--call ID' },
+                            { name: 'transfer', description: 'Transfer a live call to another number', hint: '--call ID --to +1...' },
                         ],
                         fromHome,
                     });
                     break;
                 }
+                if (flags.help && subcommand && PHONE_HELP[subcommand]) {
+                    subcommandHelp('phone', subcommand, PHONE_HELP[subcommand]);
+                    break;
+                }
                 switch (subcommand) {
                     case 'search': {
                         const country = flags.country || 'US';
@@ -735,12 +1096,130 @@ async function main() {
                         render(React.createElement(SuccessScreen, { version: VERSION, title: 'calling', subtitle: to, details: [{ label: 'To', value: to }, { label: 'Call ID', value: data.callControlId || data.id || '' }], footerLeft: 'Call initiated' }));
                         break;
                     }
-                    default: err(`Unknown phone command: ${subcommand}. Try: search, buy, sms, call`);
+                    case 'list': {
+                        const data = await ao.phoneListNumbers();
+                        return print(data);
+                    }
+                    case 'messages': {
+                        const id = flags.id || positional[0];
+                        if (!id)
+                            err('--id PHONE_ID required');
+                        const data = await ao.phoneMessages(id);
+                        return print(data);
+                    }
+                    case 'calls': {
+                        const id = flags.id || positional[0];
+                        if (!id)
+                            err('--id PHONE_ID required');
+                        const data = await ao.phoneCalls(id);
+                        return print(data);
+                    }
+                    case 'release': {
+                        const id = flags.id || positional[0];
+                        if (!id)
+                            err('--id PHONE_ID required');
+                        const data = await ao.phoneRelease(id);
+                        return print(data);
+                    }
+                    case 'call-info': {
+                        const callId = flags.call || flags.id || positional[0];
+                        if (!callId)
+                            err('--call CALL_CONTROL_ID required');
+                        const data = await ao.phoneCallInfo(callId);
+                        return print(data);
+                    }
+                    case 'speak': {
+                        const callId = flags.call || flags.id;
+                        const text = flags.text || flags.tts;
+                        if (!callId || !text)
+                            err('--call <id>, --text <text> required');
+                        const voice = flags.voice;
+                        const language = flags.language;
+                        const data = await ao.phoneSpeak(callId, text, { ...(voice ? { voice } : {}), ...(language ? { language } : {}) });
+                        return print(data);
+                    }
+                    case 'play': {
+                        const callId = flags.call || flags.id;
+                        const audioUrl = flags.url || flags['audio-url'];
+                        if (!callId || !audioUrl)
+                            err('--call <id>, --url <https://...> required');
+                        const data = await ao.phonePlay(callId, audioUrl);
+                        return print(data);
+                    }
+                    case 'dtmf': {
+                        const callId = flags.call || flags.id;
+                        const digits = flags.digits || positional[0];
+                        if (!callId || !digits)
+                            err('--call <id>, --digits "1234#" required');
+                        const data = await ao.phoneDtmf(callId, digits);
+                        return print(data);
+                    }
+                    case 'gather': {
+                        const callId = flags.call || flags.id;
+                        if (!callId)
+                            err('--call <id> required');
+                        const parseInt0 = (v) => (typeof v === 'string' ? parseInt(v, 10) : undefined);
+                        const opts = {};
+                        const minDigits = parseInt0(flags['min-digits']);
+                        if (minDigits !== undefined && Number.isFinite(minDigits))
+                            opts.minDigits = minDigits;
+                        const maxDigits = parseInt0(flags['max-digits']);
+                        if (maxDigits !== undefined && Number.isFinite(maxDigits))
+                            opts.maxDigits = maxDigits;
+                        const timeoutMillis = parseInt0(flags.timeout);
+                        if (timeoutMillis !== undefined && Number.isFinite(timeoutMillis))
+                            opts.timeoutMillis = timeoutMillis;
+                        if (flags['terminating-digit'])
+                            opts.terminatingDigit = flags['terminating-digit'];
+                        if (flags.prompt)
+                            opts.prompt = flags.prompt;
+                        if (flags['prompt-voice'])
+                            opts.promptVoice = flags['prompt-voice'];
+                        const data = await ao.phoneGather(callId, opts);
+                        return print(data);
+                    }
+                    case 'record': {
+                        const callId = flags.call || flags.id;
+                        if (!callId)
+                            err('--call <id> required');
+                        const data = await ao.phoneRecord(callId, flags.format);
+                        return print(data);
+                    }
+                    case 'record-stop': {
+                        const callId = flags.call || flags.id;
+                        if (!callId)
+                            err('--call <id> required');
+                        const data = await ao.phoneRecordStop(callId);
+                        return print(data);
+                    }
+                    case 'hangup': {
+                        const callId = flags.call || flags.id;
+                        if (!callId)
+                            err('--call <id> required');
+                        const data = await ao.phoneHangup(callId);
+                        return print(data);
+                    }
+                    case 'answer': {
+                        const callId = flags.call || flags.id;
+                        if (!callId)
+                            err('--call <id> required');
+                        const data = await ao.phoneAnswer(callId);
+                        return print(data);
+                    }
+                    case 'transfer': {
+                        const callId = flags.call || flags.id;
+                        const to = flags.to;
+                        if (!callId || !to)
+                            err('--call <id>, --to <+E.164> required');
+                        const data = await ao.phoneTransfer(callId, to);
+                        return print(data);
+                    }
+                    default: err(`Unknown phone command: ${subcommand}. Try: search, buy, list, release, sms, messages, call, calls, call-info, speak, play, dtmf, gather, record, record-stop, hangup, answer, transfer`);
                 }
                 break;
             }
             case 'email': {
-                if (!subcommand || flags.help) {
+                if (!subcommand || (flags.help && !EMAIL_HELP[subcommand])) {
                     showMenu({
                         command: 'email',
                         title: 'email',
@@ -759,6 +1238,10 @@ async function main() {
                     });
                     break;
                 }
+                if (flags.help && subcommand && EMAIL_HELP[subcommand]) {
+                    subcommandHelp('email', subcommand, EMAIL_HELP[subcommand]);
+                    break;
+                }
                 switch (subcommand) {
                     case 'create': {
                         const name = flags.name || positional[0];
@@ -850,7 +1333,7 @@ async function main() {
                 break;
             }
             case 'compute': {
-                if (!subcommand || flags.help) {
+                if (!subcommand || (flags.help && !COMPUTE_HELP[subcommand])) {
                     showMenu({
                         command: 'compute',
                         title: 'compute',
@@ -877,6 +1360,10 @@ async function main() {
                     });
                     break;
                 }
+                if (flags.help && subcommand && COMPUTE_HELP[subcommand]) {
+                    subcommandHelp('compute', subcommand, COMPUTE_HELP[subcommand]);
+                    break;
+                }
                 switch (subcommand) {
                     case 'plans': {
                         // --location filters to types deployable in that location. Each
@@ -1452,7 +1939,7 @@ async function main() {
                 break;
             }
             case 'domain': {
-                if (!subcommand || flags.help) {
+                if (!subcommand || (flags.help && !DOMAIN_HELP[subcommand])) {
                     showMenu({
                         command: 'domain',
                         title: 'domain',
@@ -1472,6 +1959,10 @@ async function main() {
                     });
                     break;
                 }
+                if (flags.help && subcommand && DOMAIN_HELP[subcommand]) {
+                    subcommandHelp('domain', subcommand, DOMAIN_HELP[subcommand]);
+                    break;
+                }
                 switch (subcommand) {
                     case 'check': {
                         const name = flags.name || positional[0];
@@ -1636,11 +2127,14 @@ async function main() {
                         subtitle: 'Non-custodial HD wallet',
                         footerLeft: 'Solana + Base wallet operations',
                         commands: [
-                            { name: 'create', description: 'Create a new wallet', hint: '[--managed]' },
-                            { name: 'import', description: 'Import from mnemonic', hint: '--mnemonic "..."' },
-                            { name: 'list', description: 'List all wallets' },
+                            { name: 'create', description: 'Create one or many wallets', hint: '[--tag X --count 100] [--solana|--base] [--managed]' },
+                            { name: 'import', description: 'Import from mnemonic', hint: '--mnemonic "..." [--tag X]' },
+                            { name: 'list', description: 'List all wallets', hint: '[--tag <name>]' },
                             { name: 'info', description: 'Wallet details', hint: 'WALLET_ID' },
                             { name: 'addresses', description: 'Show all chain addresses', hint: 'WALLET_ID' },
+                            { name: 'tags', description: 'List wallet tags with counts' },
+                            { name: 'tag', description: 'Assign / change / clear a wallet tag', hint: 'WALLET_ID TAG | WALLET_ID --clear' },
+                            { name: 'tag-delete', description: 'Cascade-delete every wallet under a tag', hint: 'TAG --confirm' },
                             { name: 'sign-message', description: 'Sign a message', hint: 'WALLET_ID --chain evm --msg "hello"' },
                             { name: 'export', description: 'Export mnemonic for backup', hint: 'WALLET_ID --confirm' },
                             { name: 'api-key', description: 'Create agent API key', hint: 'WALLET_ID --name my-agent' },
@@ -1679,16 +2173,72 @@ async function main() {
                 switch (subcommand) {
                     case 'create': {
                         const isManaged = !!flags.managed;
+                        const tagRaw = flags.tag || undefined;
+                        const countRaw = flags.count;
+                        const count = countRaw !== undefined ? parseInt(String(countRaw), 10) : 1;
+                        if (!Number.isFinite(count) || count < 1)
+                            err('--count must be a positive integer', EXIT.BAD_INPUT);
+                        // Chain filter: --solana / --base. Default (neither) → both chains.
+                        const wantSol = !!flags.solana;
+                        const wantBase = !!flags.base;
+                        const chains = (wantSol && !wantBase) ? ['solana']
+                            : (wantBase && !wantSol) ? ['base']
+                                : ['solana', 'base'];
+                        // ─── Bulk path ───
+                        if (count > 1) {
+                            if (isManaged)
+                                err('Bulk wallet creation only supports unmanaged wallets — managed wallets need per-wallet passkey setup.', EXIT.BAD_INPUT);
+                            if (!tagRaw)
+                                err('--tag is required when --count > 1', EXIT.BAD_INPUT);
+                            if (count > 500)
+                                err('--count must be ≤ 500 per call', EXIT.BAD_INPUT);
+                            const prefix = flags['name-prefix'] || tagRaw;
+                            const { createLocalWalletsBatch } = await import('./vault.js');
+                            const { storeSecretsBatch } = await import('./credential-store.js');
+                            // Progress to stderr so JSON on stdout stays clean
+                            if (!AGENT_MODE)
+                                process.stderr.write(`creating ${count} wallets under tag "${tagRaw}"...\n`);
+                            const results = createLocalWalletsBatch(prefix, count, 'unmanaged', { tag: tagRaw, chains });
+                            if (!AGENT_MODE)
+                                process.stderr.write(`sealing ${count} session secrets in OS credential store...\n`);
+                            storeSecretsBatch(results.map(r => ({ account: r.id, secret: r.sessionSecret })));
+                            log(`wallet create: ${count} wallets under tag "${tagRaw}" (chains=${chains.join(',')})`);
+                            if (AGENT_MODE) {
+                                print({
+                                    count: results.length,
+                                    tag: tagRaw,
+                                    chains,
+                                    wallets: results.map(r => ({
+                                        id: r.id,
+                                        name: r.name,
+                                        mode: r.mode,
+                                        tag: r.tag,
+                                        chains: r.chains,
+                                        solana: r.solanaAddress,
+                                        base: r.evmAddress,
+                                    })),
+                                });
+                            }
+                            else {
+                                console.log(`\n  ${t.success}✔${t.reset} Created ${count} wallets under tag ${t.accent}${tagRaw}${t.reset}`);
+                                console.log(`  ${t.muted}chains:${t.reset} ${chains.join(', ')}`);
+                                console.log(`  ${t.muted}names: ${t.reset}${results[0].name} … ${results[results.length - 1].name}`);
+                                console.log(`\n  ${t.muted}List them:    ${t.reset}palmyr wallet list --tag ${tagRaw}`);
+                                console.log(`  ${t.muted}Delete all:   ${t.reset}palmyr wallet tag-delete ${tagRaw} --confirm\n`);
+                            }
+                            break;
+                        }
+                        // ─── Single-create path ───
                         // Accept --name (primary) or --label (alias)
                         const name = flags.name || flags.label || 'My Wallet';
                         const mode = isManaged ? 'managed' : 'unmanaged';
                         // Create locally — no server needed for the key material
                         const { createLocalWallet } = await import('./vault.js');
-                        const w = createLocalWallet(name, mode);
+                        const w = createLocalWallet(name, mode, { tag: tagRaw, chains });
                         // Store session secret in OS credential store
                         const { storeSecret } = await import('./credential-store.js');
                         storeSecret(w.id, w.sessionSecret);
-                        log(`wallet create: ${w.id} (${mode})`);
+                        log(`wallet create: ${w.id} (${mode}${tagRaw ? `, tag=${tagRaw}` : ''}, chains=${chains.join(',')})`);
                         // For managed wallets, register metadata with the server to get a setup link
                         let setupLink;
                         if (isManaged) {
@@ -1723,6 +2273,7 @@ async function main() {
                                 mode: w.mode,
                                 solana: w.solanaAddress,
                                 base: w.evmAddress,
+                                tag: w.tag,
                             }));
                             if (setupLink) {
                                 console.log(`\n  ${t.accent}Setup link${t.reset} — send to the human who will manage this wallet:`);
@@ -1741,8 +2292,14 @@ async function main() {
                             err('--mnemonic "your twelve words..." required');
                         const name = flags.name || flags.label || 'Imported Wallet';
                         const mode = flags.managed ? 'managed' : 'unmanaged';
+                        const tagRaw = flags.tag || undefined;
+                        const wantSol = !!flags.solana;
+                        const wantBase = !!flags.base;
+                        const chains = (wantSol && !wantBase) ? ['solana']
+                            : (wantBase && !wantSol) ? ['base']
+                                : ['solana', 'base'];
                         const { importLocalWallet } = await import('./vault.js');
-                        const w = importLocalWallet(name, mnemonic, mode);
+                        const w = importLocalWallet(name, mnemonic, mode, { tag: tagRaw, chains });
                         // Store session secret
                         const { storeSecret } = await import('./credential-store.js');
                         storeSecret(w.id, w.sessionSecret);
@@ -1755,6 +2312,7 @@ async function main() {
                                 mode: w.mode,
                                 solana: w.solanaAddress,
                                 base: w.evmAddress,
+                                tag: w.tag,
                             }));
                         }
                         else {
@@ -1765,7 +2323,10 @@ async function main() {
                     case 'list': {
                         // List from local vault — no server needed
                         const { listVaultWallets } = await import('./vault.js');
-                        const wallets = listVaultWallets();
+                        const tagFilter = flags.tag;
+                        let wallets = listVaultWallets();
+                        if (tagFilter)
+                            wallets = wallets.filter(w => w.tag === tagFilter);
                         if (!AGENT_MODE) {
                             render(React.createElement(WalletListScreen, {
                                 version: VERSION,
@@ -1775,14 +2336,93 @@ async function main() {
                                     mode: w.mode,
                                     solana: w.solanaAddress,
                                     base: w.evmAddress,
+                                    tag: w.tag,
                                 })),
                             }));
                         }
                         else {
-                            print({ wallets });
+                            print({ wallets, ...(tagFilter ? { tag: tagFilter } : {}) });
+                        }
+                        break;
+                    }
+                    case 'tags': {
+                        const { listTags } = await import('./vault.js');
+                        const tags = listTags();
+                        if (AGENT_MODE) {
+                            print({ tags });
+                        }
+                        else {
+                            if (tags.length === 0) {
+                                console.log(`\n  ${t.muted}No tagged wallets yet.${t.reset}`);
+                                console.log(`  ${t.muted}Create some:  ${t.reset}palmyr wallet create --tag demo --count 5\n`);
+                            }
+                            else {
+                                console.log(`\n  ${t.accent}wallet tags${t.reset}`);
+                                for (const tg of tags) {
+                                    console.log(`  ${t.bold}${tg.name}${t.reset} ${t.muted}·${t.reset} ${tg.count} wallet(s) ${t.muted}·${t.reset} ${tg.chains.join(',')}`);
+                                }
+                                console.log('');
+                            }
                         }
                         break;
                     }
+                    case 'tag': {
+                        const walletId = positional[0] || flags.id;
+                        if (!walletId)
+                            err('Wallet ID required: palmyr wallet tag <WALLET_ID> <TAG> | --clear', EXIT.BAD_INPUT);
+                        const wantClear = !!flags.clear;
+                        const newTag = positional[1] || flags.tag;
+                        if (!wantClear && !newTag)
+                            err('Pass a TAG or --clear', EXIT.BAD_INPUT);
+                        if (wantClear && newTag)
+                            err('Cannot pass both a TAG and --clear', EXIT.BAD_INPUT);
+                        const { tagWallet } = await import('./vault.js');
+                        const out = tagWallet(walletId, wantClear ? null : newTag);
+                        log(`wallet tag: ${out.id} → ${out.tag ?? '(cleared)'}`);
+                        print({ success: true, ...out });
+                        break;
+                    }
+                    case 'tag-delete': {
+                        const tagArg = positional[0] || flags.tag;
+                        if (!tagArg)
+                            err('Tag required: palmyr wallet tag-delete <TAG> --confirm', EXIT.BAD_INPUT);
+                        if (!flags.confirm) {
+                            err(`This will permanently delete every wallet tagged "${tagArg}" and their session secrets.\n\n` +
+                                '  Re-run with --confirm to proceed:\n' +
+                                `  palmyr wallet tag-delete ${tagArg} --confirm`, EXIT.BAD_INPUT);
+                        }
+                        const { walletsByTag, deleteLocalWallet } = await import('./vault.js');
+                        const { deleteSecret } = await import('./credential-store.js');
+                        const targets = walletsByTag(tagArg);
+                        if (targets.length === 0)
+                            err(`No wallets found with tag "${tagArg}"`, EXIT.NOT_FOUND);
+                        const deleted = [];
+                        const failed = [];
+                        for (const w of targets) {
+                            try {
+                                const out = deleteLocalWallet(w.id);
+                                try {
+                                    deleteSecret(w.id);
+                                }
+                                catch { }
+                                deleted.push(out);
+                                if (!AGENT_MODE)
+                                    process.stderr.write(`deleted ${out.name} (${out.id.slice(0, 8)}...)\n`);
+                            }
+                            catch (e) {
+                                failed.push({ id: w.id, name: w.name, error: e?.message || String(e) });
+                            }
+                        }
+                        log(`wallet tag-delete: ${deleted.length} deleted, ${failed.length} failed (tag=${tagArg})`);
+                        print({
+                            success: failed.length === 0,
+                            tag: tagArg,
+                            deleted: deleted.length,
+                            wallets: deleted,
+                            ...(failed.length > 0 ? { failed } : {}),
+                        });
+                        break;
+                    }
                     case 'info': {
                         const walletId = positional[0] || flags.id;
                         if (!walletId)
@@ -3741,12 +4381,12 @@ async function main() {
                         }
                         err(`Unknown trading-keystore subcommand: ${sub}. Try: init, unlock, lock, list, status, derive, export`, EXIT.BAD_INPUT);
                     }
-                    default: err(`Unknown wallet command: ${subcommand}. Try: create, import, list, info, export, addresses, sign-message, api-key, config, use, request-approval, buy, cohort, template, positions, position, sell, sync, pnl, journal, watch, brief, daemon, triggers, trading-keystore, evm-quote`);
+                    default: err(`Unknown wallet command: ${subcommand}. Try: create, import, list, info, tags, tag, tag-delete, export, addresses, sign-message, api-key, config, use, request-approval, buy, cohort, template, positions, position, sell, sync, pnl, journal, watch, brief, daemon, triggers, trading-keystore, evm-quote`);
                 }
                 break;
             }
             case 'chat': {
-                if (!subcommand || flags.help) {
+                if (!subcommand || (flags.help && !CHAT_HELP[subcommand])) {
                     showMenu({
                         command: 'chat',
                         title: 'chat',
@@ -3765,6 +4405,10 @@ async function main() {
                     });
                     break;
                 }
+                if (flags.help && subcommand && CHAT_HELP[subcommand]) {
+                    subcommandHelp('chat', subcommand, CHAT_HELP[subcommand]);
+                    break;
+                }
                 switch (subcommand) {
                     case 'run': {
                         const intent = (positional.join(' ') || flags.intent || '').trim();
@@ -4001,14 +4645,18 @@ async function main() {
                 const sv = await import('./social-vault.js');
                 const platform = 'twitter';
                 // Resolve a username to its server-side account_id and which table
-                // holds it. X accounts can live in two places: x_accounts (pool-bought)
-                // and social_registered_accounts (BYO-registered). The local vault
-                // doesn't track which, so we query both in parallel and find a match.
-                // Used by transfer / share / unshare to dispatch to the correct
-                // endpoint family. Returns null if the username isn't on the server.
+                // holds it. X accounts can live in THREE places:
+                //   - x_accounts (legacy pool, rarely used now)
+                //   - social_account_pool (where `palmyr twitter buy` writes)
+                //   - social_registered_accounts (BYO-registered)
+                // The local vault doesn't track which, so we query all three in
+                // parallel and find a match. Used by transfer / share / unshare
+                // to dispatch to the correct endpoint family. Returns null if the
+                // username isn't on any of them.
                 const resolveServerAccount = async (username) => {
-                    const [xMine, reg] = await Promise.allSettled([
+                    const [xMine, poolMine, reg] = await Promise.allSettled([
                         ao.xAccountsMine(),
+                        ao.socialTwitterPoolMine(),
                         ao.socialTwitterListRegistered(),
                     ]);
                     if (xMine.status === 'fulfilled') {
@@ -4016,6 +4664,11 @@ async function main() {
                         if (m)
                             return { kind: 'x_accounts', id: m.id };
                     }
+                    if (poolMine.status === 'fulfilled') {
+                        const m = (poolMine.value?.accounts || []).find((a) => a.username === username);
+                        if (m)
+                            return { kind: 'pool', id: m.id };
+                    }
                     if (reg.status === 'fulfilled') {
                         const m = (reg.value?.accounts || []).find((a) => a.username === username);
                         if (m)
@@ -4035,26 +4688,32 @@ async function main() {
                     const existing = sv.getAccount(platform, username);
                     if (existing)
                         return existing;
-                    const [xRes, regRes] = await Promise.allSettled([
+                    const [xRes, poolRes, regRes] = await Promise.allSettled([
                         ao.xAccountsMine(),
+                        ao.socialTwitterPoolMine(),
                         ao.socialTwitterRegisteredMine(),
                     ]);
                     const xMatch = xRes.status === 'fulfilled'
                         ? (xRes.value?.accounts || []).find((a) => a.username === username)
                         : null;
+                    const poolMatch = poolRes.status === 'fulfilled'
+                        ? (poolRes.value?.accounts || []).find((a) => a.username === username)
+                        : null;
                     const regMatch = regRes.status === 'fulfilled'
                         ? (regRes.value?.accounts || []).find((a) => a.username === username)
                         : null;
-                    const match = xMatch || regMatch;
+                    const match = xMatch || poolMatch || regMatch;
                     if (!match) {
                         err(`twitter account "${username}" not found locally or on the server (this wallet has no access)`, EXIT.NOT_FOUND);
                     }
+                    // Pool-mine and registered-mine return creds nested under
+                    // `credentials`; legacy x_accounts/mine returns them flat alongside
+                    // cookies. Normalize so the import works the same in either case.
                     const cookies = (match.cookies || []);
                     const ct0 = cookies.find((c) => c.name === 'ct0')?.value;
-                    // Registered accounts return creds nested under `credentials`;
-                    // pool accounts return them flat alongside cookies.
-                    const creds = regMatch
-                        ? regMatch.credentials
+                    const hasNestedCreds = poolMatch || regMatch;
+                    const creds = hasNestedCreds
+                        ? match.credentials
                         : {
                             login: match.email || match.username,
                             password: match.password,
@@ -4062,11 +4721,16 @@ async function main() {
                             auth_token: match.auth_token || undefined,
                             ct0,
                         };
-                    const summary = sv.importAccount(platform, username, creds, { source: 'auto-claim' });
+                    const summary = sv.importAccount(platform, username, creds, {
+                        source: 'auto-claim',
+                        proxy_session_id: poolMatch?.proxy_session_id,
+                        country: poolMatch?.country || undefined,
+                    });
                     if (cookies.length > 0) {
                         sv.saveSession(summary.id, platform, cookies);
                     }
-                    log(`auto-imported @${username} from server (${regMatch ? 'registered' : 'pool'} → local vault)`);
+                    const sourceLabel = poolMatch ? 'pool' : regMatch ? 'registered' : 'x_accounts';
+                    log(`auto-imported @${username} from server (${sourceLabel} → local vault)`);
                     return summary;
                 };
                 if (!subcommand) {
@@ -4171,11 +4835,13 @@ async function main() {
                         if (skipRemote) {
                             return print({ accounts: localAccounts, count: localAccounts.length, source: 'local' });
                         }
-                        const [xRes, regRes] = await Promise.allSettled([
+                        const [xRes, poolRes, regRes] = await Promise.allSettled([
                             ao.xAccountsMine(),
+                            ao.socialTwitterPoolMine(),
                             ao.socialTwitterRegisteredMine(),
                         ]);
                         const xAccounts = xRes.status === 'fulfilled' ? (xRes.value?.accounts || []) : [];
+                        const poolAccounts = poolRes.status === 'fulfilled' ? (poolRes.value?.accounts || []) : [];
                         const regAccounts = regRes.status === 'fulfilled' ? (regRes.value?.accounts || []) : [];
                         const localUsernames = new Set(localAccounts.map(a => a.username));
                         const serverOnly = [];
@@ -4189,6 +4855,16 @@ async function main() {
                                 });
                             }
                         }
+                        for (const a of poolAccounts) {
+                            if (a.username && !localUsernames.has(a.username)) {
+                                serverOnly.push({
+                                    username: a.username,
+                                    access: a.access || 'owner',
+                                    source_table: 'pool',
+                                    status: 'server-only — run `palmyr twitter claim` to import',
+                                });
+                            }
+                        }
                         for (const a of regAccounts) {
                             if (a.username && !localUsernames.has(a.username)) {
                                 serverOnly.push({
@@ -5088,6 +5764,13 @@ async function main() {
                             spinReg.stop('Registered', true);
                             resolved = { kind: 'registered', id: regData.id };
                         }
+                        // Transfer-on-pool isn't wired yet (pool table has no transfer
+                        // endpoint with the async rotation machinery). Surface a clear
+                        // workaround instead of a silent 404.
+                        if (resolved.kind === 'pool') {
+                            err(`@${username} is a pool-bought account and transfer isn't supported on the pool table yet — share/unshare work.\n\n` +
+                                `Workaround: \`palmyr twitter register ${username}\` first (uploads to the registered table), then re-run the transfer.`, EXIT.GENERAL);
+                        }
                         const spin = new Spinner();
                         spin.start(`Rotating @${username} password and transferring…`);
                         // Kick off the transfer. Server responds 202 with a transfer_id;
@@ -5169,7 +5852,9 @@ async function main() {
                         }
                         const data = resolved.kind === 'x_accounts'
                             ? await ao.xAccountShare(resolved.id, withWallet)
-                            : await ao.socialTwitterRegisteredShare(resolved.id, withWallet);
+                            : resolved.kind === 'pool'
+                                ? await ao.socialTwitterPoolShare(resolved.id, withWallet)
+                                : await ao.socialTwitterRegisteredShare(resolved.id, withWallet);
                         log(`twitter share: @${username} → ${withWallet}`);
                         return print({ ...data, source_table: resolved.kind });
                     }
@@ -5193,9 +5878,20 @@ async function main() {
                             spin.start(`Unsharing @${username} and rotating password…`);
                         let data;
                         try {
-                            data = resolved.kind === 'x_accounts'
-                                ? await ao.xAccountUnshare(resolved.id, targetWallet, { rotate })
-                                : await ao.socialTwitterRegisteredUnshare(resolved.id, targetWallet, { rotate });
+                            if (resolved.kind === 'x_accounts') {
+                                data = await ao.xAccountUnshare(resolved.id, targetWallet, { rotate });
+                            }
+                            else if (resolved.kind === 'pool') {
+                                // The pool unshare endpoint doesn't support rotate today
+                                // (rotation infra lives on the transfers async pipeline and
+                                // hasn't been wired to pool yet). Warn and call without rotate.
+                                if (rotate)
+                                    warn(`--rotate not supported on pool-bought accounts yet — performing unshare only`);
+                                data = await ao.socialTwitterPoolUnshare(resolved.id, targetWallet);
+                            }
+                            else {
+                                data = await ao.socialTwitterRegisteredUnshare(resolved.id, targetWallet, { rotate });
+                            }
                         }
                         catch (e) {
                             if (spin)
@@ -5284,20 +5980,23 @@ async function main() {
                     }
                     case 'claim': {
                         // Fetch server-side accounts the calling wallet owns or has shared
-                        // access to — from BOTH tables. x_accounts (pool-bought) and
+                        // access to — from all THREE tables. x_accounts (legacy pool),
+                        // social_account_pool (where `palmyr twitter buy` writes), and
                         // social_registered_accounts (BYO-registered) are queried in
-                        // parallel; both contribute to the claim list. Import any not
-                        // already in the local vault so the receiver of a transfer can
-                        // pick up the account in one command.
-                        const [xRes, regRes] = await Promise.allSettled([
+                        // parallel; all three contribute to the claim list. Import any
+                        // not already in the local vault so the receiver of a transfer
+                        // or share can pick up the account in one command.
+                        const [xRes, poolRes, regRes] = await Promise.allSettled([
                             ao.xAccountsMine(),
+                            ao.socialTwitterPoolMine(),
                             ao.socialTwitterRegisteredMine(),
                         ]);
                         const xAccounts = xRes.status === 'fulfilled' ? (xRes.value?.accounts || []) : [];
+                        const poolAccountsRaw = poolRes.status === 'fulfilled' ? (poolRes.value?.accounts || []) : [];
                         const regAccountsRaw = regRes.status === 'fulfilled' ? (regRes.value?.accounts || []) : [];
-                        // Normalize the registered shape (creds + cookies live in nested
-                        // fields) to the same flat shape as x_accounts so the loop below
-                        // doesn't have to branch on source.
+                        // Normalize the registered + pool shape (creds + cookies live in
+                        // nested fields) to the same flat shape as x_accounts so the
+                        // loop below doesn't have to branch on source.
                         const regAccounts = regAccountsRaw.map(a => ({
                             username: a.username,
                             email: a.credentials?.email,
@@ -5307,8 +6006,20 @@ async function main() {
                             access: a.access,
                             source_table: 'registered',
                         }));
+                        const poolAccounts = poolAccountsRaw.map(a => ({
+                            username: a.username,
+                            email: a.credentials?.email,
+                            password: a.credentials?.password,
+                            auth_token: a.credentials?.auth_token,
+                            cookies: a.cookies || [],
+                            access: a.access,
+                            proxy_session_id: a.proxy_session_id,
+                            country: a.country,
+                            source_table: 'pool',
+                        }));
                         const accounts = [
                             ...xAccounts.map(a => ({ ...a, source_table: 'x_accounts' })),
+                            ...poolAccounts,
                             ...regAccounts,
                         ];
                         if (accounts.length === 0) {
@@ -5332,7 +6043,11 @@ async function main() {
                                     auth_token: a.auth_token || undefined,
                                     ct0,
                                 };
-                                const summary = sv.importAccount(platform, a.username, creds, { source: 'claim' });
+                                const summary = sv.importAccount(platform, a.username, creds, {
+                                    source: 'claim',
+                                    proxy_session_id: a.proxy_session_id,
+                                    country: a.country || undefined,
+                                });
                                 // Save the cookies so `palmyr twitter login` can use the
                                 // cookie-fast-path instead of re-driving the login form.
                                 if (Array.isArray(a.cookies) && a.cookies.length > 0) {