@palmyr/cli 1.5.0 → 1.5.6

package/README.md

@@ -498,7 +498,7 @@ Local credentials are encrypted with AES-256-GCM (per-account session secret in
 | `palmyr twitter buy` | $5.00 | Pay $5 USDC, receive a ready X account from the pool. Auto-imports into the local vault and primes the session — you can post immediately. |
 | `palmyr twitter import <username> --credentials-line "login:pw:email:email_pw:2fa:ct0:auth_token"` | free | Bring your own account. Accepts the standard 4 / 5 / 7-field colon format common in marketplace exports. |
 | `palmyr twitter import <username> --login E --password P [--email-password X] [--totp-seed S] [--auth-token T --ct0 C]` | free | Same, with explicit flags. |
-| `palmyr twitter list` | free | List local accounts. |
+| `palmyr twitter list [--local]` | $0.0011 *(ownership proof on `/x/accounts/mine` + `/social/twitter/registered/mine`)* — `--local` skips the server check for free | Local vault PLUS server-side accounts the wallet owns or has been shared with. Server-only accounts appear with a `server-only — run 'palmyr twitter claim' to import` hint. Default behavior queries the server so a wallet that just received a transfer sees the account without an extra `claim` step. |
 | `palmyr twitter info <username>` | free | Show one account (id, addresses, last action, source). |
 | `palmyr twitter rename <old> --to <new>` | free | Rename the local handle (does not change the X handle — use `twitter username` for that). |
 | `palmyr twitter remove <username> --confirm` | free | Delete the local copy. The X account itself is not deleted. |
@@ -522,10 +522,10 @@ Local credentials are encrypted with AES-256-GCM (per-account session secret in
 | `palmyr twitter pfp <username> --file path.png` *(or `--url https://...`)* | $0.005 | PNG / JPG / WebP / GIF. Local file is base64-encoded; URL is fetched server-side with SSRF guard. |
 | `palmyr twitter banner <username> --file path.png` *(or `--url ...`)* | $0.005 | |
 | `palmyr twitter username <username> --to <new-handle>` | $0.005 | Pre-flight validates handle (4–15 chars, `[A-Za-z0-9_]`) before payment. May trigger X's password re-auth modal — handled automatically. |
-| `palmyr twitter transfer <username> --to <wallet> --confirm` | $0.0001 *(ownership proof)* | Atomically hand the X account to another wallet. Server rotates the password and revokes other sessions before flipping `sold_to`, so the local copy of credentials becomes useless. Requires `--confirm`. Local vault entry is removed on success — receiver picks up fresh creds with `palmyr twitter claim`. |
-| `palmyr twitter share <username> --with <wallet>` | $0.0001 *(ownership proof)* | Grant another wallet shared access — same login, no credential rotation. Both wallets see the account via `palmyr twitter claim`. Owner-only. |
-| `palmyr twitter unshare <username> --from <wallet> [--rotate]` | $0.0001 *(ownership proof; rotation runs through Playwright when `--rotate`)* | Revoke a wallet's shared access. Without `--rotate`, the wallet is removed from `shared_with` but their previously exported cookies / password remain valid until X-side expiry. With `--rotate`, the server also rotates the password and revokes other sessions, then the CLI updates the local vault in place. Owner-only. |
-| `palmyr twitter claim` | $0.0001 *(ownership proof)* | Pull every X account on the server bound to your wallet (owner or shared) into the local vault, with session cookies pre-warmed. The fast path for a wallet that just received a transferred account. |
+| `palmyr twitter transfer <username> --to <wallet> --confirm` | $0.0001 ownership proof + $0.0011 lookup; **adds $0.01 if auto-register runs**; **plus ~$0.001 in poll fees** ($0.0001 × ~10 polls) | Atomically hand the X account to another wallet. End-to-end one-command: looks up the account in both server tables (`x_accounts` + `social_registered_accounts`), auto-registers if only in local vault, then kicks off an async rotation job. Server returns `{ transfer_id }` immediately and the CLI polls `/transfers/:id` every 5s until `completed` or `failed` (rotation takes 30-90s in the background — async so it survives Cloudflare's HTTP timeout). Password is rotated and other sessions revoked before ownership flips, so the local copy of credentials becomes useless. Requires `--confirm`. Local vault entry is removed on success — receiver picks up fresh creds with `palmyr twitter list` (which shows server-only accounts) and/or `palmyr twitter claim`. |
+| `palmyr twitter share <username> --with <wallet>` | $0.0001 *(ownership proof)* | Grant another wallet shared access — same login, no credential rotation. Both wallets see the account via `palmyr twitter claim`. Owner-only. Same pool / registered dispatch as transfer. |
+| `palmyr twitter unshare <username> --from <wallet> [--rotate]` | $0.0001 ownership proof + $0.0011 lookup; **with `--rotate`: kicks off async rotation, ~$0.001 in poll fees plus another lookup to sync local vault** | Revoke a wallet's shared access. Without `--rotate`, the wallet is removed from `shared_with` immediately but their previously exported cookies / password remain valid until X-side expiry. With `--rotate`, the unshare is immediate AND the server kicks off an async password rotation (same machinery as transfer — Playwright + polling so it survives Cloudflare's HTTP timeout). On completion, the CLI fetches the new credentials from the appropriate `/mine` endpoint and updates the local vault in place. Owner-only. Same pool / registered dispatch. |
+| `palmyr twitter claim` | $0.0011 *(ownership proof on both `/x/accounts/mine` and `/social/twitter/registered/mine`)* | Pull every X account on the server bound to your wallet (owner or shared) into the local vault, with session cookies pre-warmed. Queries both server tables in parallel. The fast path for a wallet that just received a transferred account. |
 
 **Verification.** Operations are confirmed at the network layer — the server intercepts X's actual API responses (`CreateTweet`, `FavoriteTweet`, `update_profile`, etc.) before reporting success. No false positives.
 

package/dist/cli.js

@@ -4000,6 +4000,75 @@ async function main() {
             case 'twitter': {
                 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.
+                const resolveServerAccount = async (username) => {
+                    const [xMine, reg] = await Promise.allSettled([
+                        ao.xAccountsMine(),
+                        ao.socialTwitterListRegistered(),
+                    ]);
+                    if (xMine.status === 'fulfilled') {
+                        const m = (xMine.value?.accounts || []).find((a) => a.username === username);
+                        if (m)
+                            return { kind: 'x_accounts', id: m.id };
+                    }
+                    if (reg.status === 'fulfilled') {
+                        const m = (reg.value?.accounts || []).find((a) => a.username === username);
+                        if (m)
+                            return { kind: 'registered', id: m.id };
+                    }
+                    return null;
+                };
+                // Look up an account by username; if it's not in the local vault,
+                // check both server-side tables and auto-import any match. This is
+                // what makes `palmyr twitter <op> @h` "just work" for a wallet that
+                // was just transferred or shared an account — no separate `claim`
+                // step. Errs cleanly if the account is neither local nor accessible
+                // server-side. Each auto-import costs ~$0.0011 (two paid lookups +
+                // creds-decryption fee on the registered side), so call sites that
+                // are pure local ops (rename, remove) intentionally skip this.
+                const ensureLocalAccount = async (username) => {
+                    const existing = sv.getAccount(platform, username);
+                    if (existing)
+                        return existing;
+                    const [xRes, regRes] = await Promise.allSettled([
+                        ao.xAccountsMine(),
+                        ao.socialTwitterRegisteredMine(),
+                    ]);
+                    const xMatch = xRes.status === 'fulfilled'
+                        ? (xRes.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;
+                    if (!match) {
+                        err(`twitter account "${username}" not found locally or on the server (this wallet has no access)`, EXIT.NOT_FOUND);
+                    }
+                    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
+                        : {
+                            login: match.email || match.username,
+                            password: match.password,
+                            email: match.email,
+                            auth_token: match.auth_token || undefined,
+                            ct0,
+                        };
+                    const summary = sv.importAccount(platform, username, creds, { source: 'auto-claim' });
+                    if (cookies.length > 0) {
+                        sv.saveSession(summary.id, platform, cookies);
+                    }
+                    log(`auto-imported @${username} from server (${regMatch ? 'registered' : 'pool'} → local vault)`);
+                    return summary;
+                };
                 if (!subcommand) {
                     showMenu({
                         command: 'twitter',
@@ -4008,7 +4077,7 @@ async function main() {
                         footerLeft: 'Phase 1: local vault + BYO import works today. Server-dependent commands stub out.',
                         commands: [
                             { name: 'import', description: 'Save a BYO account to the local vault', hint: '--username --password --totp-seed' },
-                            { name: 'list', description: 'List all local X accounts' },
+                            { name: 'list', description: 'List local accounts and any server-only ones the wallet can access', hint: '[--local]' },
                             { name: 'info', description: 'Show one account', hint: '<username>' },
                             { name: 'rename', description: 'Update the local record when the handle changes', hint: '<old> --to <new>' },
                             { name: 'remove', description: 'Delete an account from the local vault', hint: '<username> --confirm' },
@@ -4017,7 +4086,7 @@ async function main() {
                             { name: 'login', description: 'Force a fresh server-side session (requires browser runtime)', hint: '<username>' },
                             { name: 'post', description: 'Post a tweet (requires server browser runtime)', hint: '<username> --body "..."' },
                             { name: 'status', description: 'Check if the account is alive / shadow-banned', hint: '<username>' },
-                            { name: 'transfer', description: 'Hand an account to another wallet (rotates password)', hint: '<username> --to <wallet>' },
+                            { name: 'transfer', description: 'Hand an account to another wallet (rotates password; auto-registers if needed)', hint: '<username> --to <wallet> --confirm' },
                             { name: 'share', description: 'Grant another wallet shared access', hint: '<username> --with <wallet>' },
                             { name: 'unshare', description: 'Revoke a wallet’s shared access', hint: '<username> --from <wallet> [--rotate]' },
                             { name: 'claim', description: 'Import server-side accounts owned by your wallet into the local vault' },
@@ -4092,16 +4161,59 @@ async function main() {
                         return print({ ...summary, has_cookies: !!authToken });
                     }
                     case 'list': {
-                        const accounts = sv.listAccounts(platform);
-                        return print({ accounts, count: accounts.length });
+                        // Local vault is always queried (free, instant). By default we
+                        // also query the server for accounts the wallet owns or has been
+                        // shared with — that's how a wallet that just received a transfer
+                        // sees the account here without an extra `claim` step. Pass
+                        // --local to skip the server check for cheap mode.
+                        const localAccounts = sv.listAccounts(platform);
+                        const skipRemote = !!flags.local;
+                        if (skipRemote) {
+                            return print({ accounts: localAccounts, count: localAccounts.length, source: 'local' });
+                        }
+                        const [xRes, regRes] = await Promise.allSettled([
+                            ao.xAccountsMine(),
+                            ao.socialTwitterRegisteredMine(),
+                        ]);
+                        const xAccounts = xRes.status === 'fulfilled' ? (xRes.value?.accounts || []) : [];
+                        const regAccounts = regRes.status === 'fulfilled' ? (regRes.value?.accounts || []) : [];
+                        const localUsernames = new Set(localAccounts.map(a => a.username));
+                        const serverOnly = [];
+                        for (const a of xAccounts) {
+                            if (a.username && !localUsernames.has(a.username)) {
+                                serverOnly.push({
+                                    username: a.username,
+                                    access: a.access || 'owner',
+                                    source_table: 'x_accounts',
+                                    status: 'server-only — run `palmyr twitter claim` to import',
+                                });
+                            }
+                        }
+                        for (const a of regAccounts) {
+                            if (a.username && !localUsernames.has(a.username)) {
+                                serverOnly.push({
+                                    username: a.username,
+                                    access: a.access || 'owner',
+                                    source_table: 'registered',
+                                    status: 'server-only — run `palmyr twitter claim` to import',
+                                });
+                            }
+                        }
+                        return print({
+                            accounts: localAccounts,
+                            server_only: serverOnly,
+                            count_local: localAccounts.length,
+                            count_server_only: serverOnly.length,
+                            ...(serverOnly.length > 0
+                                ? { hint: `${serverOnly.length} account${serverOnly.length === 1 ? '' : 's'} on server but not in local vault — run 'palmyr twitter claim' to import` }
+                                : {}),
+                        });
                     }
                     case 'info': {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err('<username> required');
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         return print(acc);
                     }
                     case 'rename': {
@@ -4132,6 +4244,7 @@ async function main() {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err('<username> required');
+                        await ensureLocalAccount(username);
                         const creds = sv.unlockCredentials(platform, username);
                         if (!creds.totp_seed)
                             err(`twitter account "${username}" has no TOTP seed configured`, EXIT.NOT_FOUND);
@@ -4235,16 +4348,14 @@ async function main() {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err('<username> required');
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess) {
                             return print({
                                 platform,
                                 username,
                                 cached: false,
-                                hint: `No cached session. Run: node cli/dist/cli.js twitter login ${username}`,
+                                hint: `No cached session. Run: palmyr twitter login ${username}`,
                             });
                         }
                         const ageHours = sv.sessionAgeHours(acc.id);
@@ -4270,9 +4381,7 @@ async function main() {
                                 err('--limit must be a positive integer', EXIT.BAD_INPUT);
                             limit = Math.floor(n);
                         }
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess || !sess.cookies || sess.cookies.length === 0) {
                             err(`No cached session for ${username}. Run 'twitter login ${username}' first.`, EXIT.NOT_FOUND);
@@ -4565,9 +4674,7 @@ async function main() {
                             err(`Invalid username "${rawNewUsername}". X requires 4-15 chars, letters/numbers/underscores only. ` +
                                 `You have NOT been charged.`, EXIT.BAD_INPUT);
                         }
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess || !sess.cookies || sess.cookies.length === 0) {
                             err(`No cached session. Run 'twitter login ${username}' first.`, EXIT.NOT_FOUND);
@@ -4610,9 +4717,7 @@ async function main() {
                         const username = positional[0] || flags.username;
                         if (!username)
                             err(`<username> required`);
-                        const acc = sv.getAccount(platform, username);
-                        if (!acc)
-                            err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const acc = await ensureLocalAccount(username);
                         const sess = sv.loadSession(acc.id);
                         if (!sess || !sess.cookies || sess.cookies.length === 0) {
                             err(`No cached session for ${username}. Run 'twitter login ${username}' first.`, EXIT.NOT_FOUND);
@@ -4829,7 +4934,7 @@ async function main() {
                             success: true,
                             platform,
                             username: summary.username,
-                            hint: `Ready to post — try: node cli/dist/cli.js twitter post ${summary.username} --body "gm"`,
+                            hint: `Ready to post — try: palmyr twitter post ${summary.username} --body "gm"`,
                         });
                     }
                     case 'pool-add': {
@@ -4918,11 +5023,14 @@ async function main() {
                         err(`twitter status: not wired yet. Phase 3 will add it.`, EXIT.GENERAL);
                     }
                     case 'transfer': {
-                        // Hand the X account to another wallet. Server rotates the password
-                        // and revokes other sessions before flipping ownership, so the local
-                        // copy of credentials we keep is intentionally invalidated. After
-                        // success, we wipe the local vault entry — receiver will pick up
-                        // fresh credentials via `palmyr twitter claim`.
+                        // Hand the X account to another wallet. End-to-end one-command:
+                        //   1. If the account is only in the local vault, auto-register it
+                        //      with the server (uploads encrypted creds; $0.01 USDC).
+                        //   2. Server rotates the password and revokes other sessions
+                        //      ($0.0001 USDC ownership proof).
+                        //   3. Atomically flips ownership in the DB.
+                        // Receiver picks up the rotated credentials via `palmyr twitter
+                        // list` (which now surfaces server-side accounts) and/or `claim`.
                         const username = positional[0] || flags.username;
                         const to = flags.to;
                         if (!username)
@@ -4936,28 +5044,114 @@ async function main() {
                             const tail = to.slice(-6);
                             err(`This rotates @${username} on X and hands it to a wallet ending in …${tail}. ` +
                                 `You will lose access immediately and irreversibly. ` +
+                                `If the account isn't on the Palmyr server yet, it will be auto-registered (~$0.01 USDC) before the transfer.\n\n` +
                                 `Re-run with --confirm:\n` +
                                 `  palmyr twitter transfer ${username} --to ${to} --confirm`);
                         }
+                        let resolved = await resolveServerAccount(username);
+                        // Auto-register if the account is only in the local vault. This
+                        // is the most common case for accounts that were imported BYO and
+                        // never explicitly registered. We pull creds straight from the
+                        // local vault so the user doesn't have to re-type anything.
+                        if (!resolved) {
+                            const spinReg = new Spinner();
+                            spinReg.start(`@${username} not on server yet — auto-registering before transfer…`);
+                            let regData;
+                            try {
+                                const localCreds = sv.unlockCredentials(platform, username);
+                                if (!localCreds.password) {
+                                    spinReg.stop('Register failed', false);
+                                    err(`Cannot auto-register @${username}: local vault has no password. ` +
+                                        `Re-import the account with a password first.`, EXIT.BAD_INPUT);
+                                }
+                                const country = sv.getCountry(platform, username);
+                                regData = await ao.socialTwitterRegister(username, localCreds.password, {
+                                    login: localCreds.login,
+                                    email: localCreds.email,
+                                    email_password: localCreds.email_password,
+                                    totp_seed: localCreds.totp_seed,
+                                    auth_token: localCreds.auth_token,
+                                    ct0: localCreds.ct0,
+                                    country,
+                                });
+                            }
+                            catch (e) {
+                                spinReg.stop('Register failed', false);
+                                err(`Auto-register failed: ${e.message}`, EXIT.GENERAL);
+                            }
+                            if (!regData?.success || !regData?.id) {
+                                spinReg.stop('Register failed', false);
+                                err(`Auto-register failed: ${regData?.error || 'unknown'}` +
+                                    (regData?.login_error_code ? ` [${regData.login_error_code}]` : '') +
+                                    `\nFix the credentials in the local vault, then re-run the transfer.`, EXIT.GENERAL);
+                            }
+                            spinReg.stop('Registered', true);
+                            resolved = { kind: 'registered', id: regData.id };
+                        }
                         const spin = new Spinner();
                         spin.start(`Rotating @${username} password and transferring…`);
-                        let data;
+                        // Kick off the transfer. Server responds 202 with a transfer_id;
+                        // the rotation runs in the background to avoid Cloudflare's HTTP
+                        // timeout. We poll /transfers/:id until it terminates.
+                        let kicked;
                         try {
-                            data = await ao.xAccountTransfer(acc.id, to);
+                            kicked = resolved.kind === 'x_accounts'
+                                ? await ao.xAccountTransfer(resolved.id, to)
+                                : await ao.socialTwitterRegisteredTransfer(resolved.id, to);
                         }
                         catch (e) {
                             spin.stop('Transfer failed', false);
                             err(`Transfer failed: ${e.message}`, EXIT.GENERAL);
                         }
+                        const transferId = kicked?.transfer_id;
+                        if (!transferId) {
+                            spin.stop('Transfer failed', false);
+                            err(`Server didn't return a transfer_id. Response: ${JSON.stringify(kicked)}`, EXIT.GENERAL);
+                        }
+                        // Poll every 5s; cap at 5 minutes so a stuck transfer doesn't
+                        // hang the CLI forever. The server's own startup sweep will mark
+                        // anything still stuck after 5 min as failed.
+                        const startedAt = Date.now();
+                        const MAX_WAIT_MS = 5 * 60 * 1000;
+                        let status = null;
+                        while (true) {
+                            if (Date.now() - startedAt > MAX_WAIT_MS) {
+                                spin.stop('Timed out waiting', false);
+                                err(`Transfer ${transferId} is still in progress after 5 min. Check status with: ` +
+                                    `curl https://palmyr.ai/transfers/${transferId} (with payment header)`, EXIT.GENERAL);
+                            }
+                            await new Promise(r => setTimeout(r, 5000));
+                            try {
+                                status = await ao.transferStatus(transferId);
+                            }
+                            catch (e) {
+                                // Transient poll failures shouldn't abort — the rotation is
+                                // still running on the server. Surface it but keep polling.
+                                spin.update(`Poll error (will retry): ${e.message}`);
+                                continue;
+                            }
+                            spin.update(`Status: ${status.status}…`);
+                            if (status.status === 'completed' || status.status === 'failed')
+                                break;
+                        }
+                        if (status.status === 'failed') {
+                            spin.stop('Transfer failed', false);
+                            err(`Transfer failed: ${status.error || 'unknown'}` +
+                                (status.error_code ? ` [${status.error_code}]` : ''), EXIT.GENERAL);
+                        }
                         spin.stop('Transferred', true);
-                        // The local vault still holds the OLD password / cookies which are
+                        // Local vault still holds the OLD password / cookies which are
                         // now useless. Drop the entry so we don't confuse the user with a
                         // ghost account they can't log into.
                         try {
                             sv.removeAccount(platform, username);
                         }
                         catch { /* best effort */ }
-                        return print({ ...data, local_vault_cleared: true });
+                        return print({
+                            ...status,
+                            source_table: resolved.kind,
+                            local_vault_cleared: true,
+                        });
                     }
                     case 'share': {
                         const username = positional[0] || flags.username;
@@ -4969,9 +5163,15 @@ async function main() {
                         const acc = sv.getAccount(platform, username);
                         if (!acc)
                             err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
-                        const data = await ao.xAccountShare(acc.id, withWallet);
+                        const resolved = await resolveServerAccount(username);
+                        if (!resolved) {
+                            err(`@${username} is not on the server. Register it first with: palmyr twitter register ${username}`, EXIT.NOT_FOUND);
+                        }
+                        const data = resolved.kind === 'x_accounts'
+                            ? await ao.xAccountShare(resolved.id, withWallet)
+                            : await ao.socialTwitterRegisteredShare(resolved.id, withWallet);
                         log(`twitter share: @${username} → ${withWallet}`);
-                        return print(data);
+                        return print({ ...data, source_table: resolved.kind });
                     }
                     case 'unshare': {
                         const username = positional[0] || flags.username;
@@ -4984,53 +5184,133 @@ async function main() {
                         const acc = sv.getAccount(platform, username);
                         if (!acc)
                             err(`twitter account "${username}" not found locally`, EXIT.NOT_FOUND);
+                        const resolved = await resolveServerAccount(username);
+                        if (!resolved) {
+                            err(`@${username} is not on the server. Register it first with: palmyr twitter register ${username}`, EXIT.NOT_FOUND);
+                        }
                         const spin = rotate ? new Spinner() : null;
                         if (spin)
                             spin.start(`Unsharing @${username} and rotating password…`);
                         let data;
                         try {
-                            data = await ao.xAccountUnshare(acc.id, targetWallet, { rotate });
+                            data = resolved.kind === 'x_accounts'
+                                ? await ao.xAccountUnshare(resolved.id, targetWallet, { rotate })
+                                : await ao.socialTwitterRegisteredUnshare(resolved.id, targetWallet, { rotate });
                         }
                         catch (e) {
                             if (spin)
                                 spin.stop('Unshare failed', false);
                             err(`Unshare failed: ${e.message}`, EXIT.GENERAL);
                         }
-                        if (spin)
-                            spin.stop(data?.rotated ? 'Unshared and rotated' : 'Unshared (rotation skipped)', !!data?.rotated);
-                        // If rotation succeeded, sync the local vault so the next op
-                        // doesn't try to log in with the now-defunct password / cookies.
-                        if (rotate && data?.rotated && data?.credentials) {
-                            try {
-                                const existing = sv.unlockCredentials(platform, username);
-                                const next = {
-                                    ...existing,
-                                    password: data.credentials.password,
-                                    auth_token: data.credentials.auth_token || undefined,
-                                    ct0: (data.credentials.cookies || []).find((c) => c.name === 'ct0')?.value || existing.ct0,
-                                };
-                                sv.replaceCredentials(platform, username, next);
-                                if (Array.isArray(data.credentials.cookies) && data.credentials.cookies.length > 0) {
-                                    sv.saveSession(acc.id, platform, data.credentials.cookies);
+                        // If the server kicked off an async rotation, poll until it
+                        // settles. Same polling pattern as transfer — Playwright takes
+                        // longer than Cloudflare's HTTP response budget.
+                        if (rotate && data?.transfer_id) {
+                            const transferId = data.transfer_id;
+                            const startedAt = Date.now();
+                            const MAX_WAIT_MS = 5 * 60 * 1000;
+                            let status = null;
+                            while (true) {
+                                if (Date.now() - startedAt > MAX_WAIT_MS) {
+                                    if (spin)
+                                        spin.stop('Rotation timed out', false);
+                                    err(`Rotation ${transferId} still in progress after 5 min. ` +
+                                        `Account is unshared but cached cookies on the revoked wallet may still work until X-side expiry. ` +
+                                        `Check status at /transfers/${transferId}.`, EXIT.GENERAL);
+                                }
+                                await new Promise(r => setTimeout(r, 5000));
+                                try {
+                                    status = await ao.transferStatus(transferId);
                                 }
-                                // Don't leak the new password into the printed JSON output —
-                                // it's already persisted locally.
-                                data = { ...data, credentials: { rotated: true, persisted_locally: true } };
+                                catch (e) {
+                                    if (spin)
+                                        spin.update(`Poll error (will retry): ${e.message}`);
+                                    continue;
+                                }
+                                if (spin)
+                                    spin.update(`Rotation: ${status.status}…`);
+                                if (status.status === 'completed' || status.status === 'failed')
+                                    break;
                             }
-                            catch (e) {
-                                warn(`Local vault sync failed: ${e.message}. Run 'palmyr twitter claim' to refresh from server.`);
+                            if (status.status === 'failed') {
+                                if (spin)
+                                    spin.stop('Rotation failed', false);
+                                warn(`Unshare succeeded but rotation failed: ${status.error || 'unknown'}` +
+                                    (status.error_code ? ` [${status.error_code}]` : '') +
+                                    `. The revoked wallet's cached cookies may still work until X-side expiry. Retry rotation if needed.`);
+                                data = { ...data, rotated: false, rotation_error: status.error, rotation_error_code: status.error_code };
+                            }
+                            else {
+                                if (spin)
+                                    spin.stop('Unshared and rotated', true);
+                                // Fetch fresh creds from the appropriate /mine endpoint and
+                                // sync the local vault. Caller is still the owner, so the
+                                // server returns the new credentials they need.
+                                try {
+                                    const mineResp = resolved.kind === 'x_accounts'
+                                        ? await ao.xAccountsMine()
+                                        : await ao.socialTwitterRegisteredMine();
+                                    const fresh = (mineResp?.accounts || []).find((a) => a.username === username);
+                                    if (fresh) {
+                                        const existing = sv.unlockCredentials(platform, username);
+                                        const isReg = resolved.kind === 'registered';
+                                        const freshPassword = isReg ? fresh.credentials?.password : fresh.password;
+                                        const freshAuth = isReg ? fresh.credentials?.auth_token : fresh.auth_token;
+                                        const freshCookies = fresh.cookies || [];
+                                        const next = {
+                                            ...existing,
+                                            password: freshPassword || existing.password,
+                                            auth_token: freshAuth || undefined,
+                                            ct0: freshCookies.find((c) => c.name === 'ct0')?.value || existing.ct0,
+                                        };
+                                        sv.replaceCredentials(platform, username, next);
+                                        if (Array.isArray(freshCookies) && freshCookies.length > 0) {
+                                            sv.saveSession(acc.id, platform, freshCookies);
+                                        }
+                                    }
+                                }
+                                catch (e) {
+                                    warn(`Local vault sync failed: ${e.message}. Run 'palmyr twitter claim' to refresh from server.`);
+                                }
+                                data = { ...data, rotated: true, credentials: { rotated: true, persisted_locally: true } };
                             }
                         }
+                        else {
+                            if (spin)
+                                spin.stop('Unshared (rotation skipped)', false);
+                        }
                         log(`twitter unshare: @${username} ✗ ${targetWallet}${rotate ? ' (rotated)' : ''}`);
-                        return print(data);
+                        return print({ ...data, source_table: resolved.kind });
                     }
                     case 'claim': {
-                        // Fetch every server-side X account this wallet owns or has shared
-                        // access to. Optionally import any not yet in the local vault —
-                        // typical use is the new owner of a transferred account picking it
-                        // up for the first time.
-                        const data = await ao.xAccountsMine();
-                        const accounts = data?.accounts || [];
+                        // Fetch server-side accounts the calling wallet owns or has shared
+                        // access to — from BOTH tables. x_accounts (pool-bought) 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([
+                            ao.xAccountsMine(),
+                            ao.socialTwitterRegisteredMine(),
+                        ]);
+                        const xAccounts = xRes.status === 'fulfilled' ? (xRes.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.
+                        const regAccounts = regAccountsRaw.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,
+                            source_table: 'registered',
+                        }));
+                        const accounts = [
+                            ...xAccounts.map(a => ({ ...a, source_table: 'x_accounts' })),
+                            ...regAccounts,
+                        ];
                         if (accounts.length === 0) {
                             log('No X accounts associated with your wallet on the server.');
                             return print({ count: 0, claimed: 0, accounts: [] });
@@ -5058,7 +5338,7 @@ async function main() {
                                 if (Array.isArray(a.cookies) && a.cookies.length > 0) {
                                     sv.saveSession(summary.id, platform, a.cookies);
                                 }
-                                imported.push({ username: a.username, id: summary.id, access: a.access });
+                                imported.push({ username: a.username, id: summary.id, access: a.access, source_table: a.source_table });
                             }
                             catch (e) {
                                 skipped.push({ username: a.username, reason: e.message });