@palmyr/cli 1.8.3 → 1.9.0

package/dist/cli.js

@@ -17,6 +17,7 @@ import { render as inkRender } from 'ink';
 import { ConfigScreen, Dashboard, DoctorScreen, DomainCheckScreen, DomainPricingScreen, ErrorScreen, HealthScreen, MenuScreen, PricingScreen, RecordsScreen, SetupScreen, StatusScreen, SuccessScreen, WalletCreateScreen, WalletStatusScreen, WalletListScreen } from './app.js';
 import { Palmyr } from './sdk.js';
 import { loadConfig, saveConfig, ensureDirs, log, addPhone, addDomain, addNote } from './config.js';
+import { getState as getTelemetryState, setEnabled as setTelemetryEnabled, queuedCount as telemetryQueuedCount, appendEventSync as telemetryAppendEvent, flushQueue as telemetryFlushQueue } from './telemetry.js';
 import { theme as t, icon, Spinner, warn, table, kv, section, setAgentMode as setUiAgentMode } from './ui.js';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
@@ -229,11 +230,10 @@ function emitSessionOnlyWarning(write) {
 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 (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: '--count <N>', desc: 'Bulk-create N wallets in one call (1-500)', hint: 'requires --tag' },
         { flag: '--name-prefix <p>', desc: 'Bulk name prefix; suffixed `-001..-N`', hint: 'default: same as --tag' },
         { flag: '--passphrase <p>', desc: 'Seal the mnemonic with this passphrase (≥8 chars) for durable recovery across reboot / OS-keychain loss / host migration', hint: 'or PALMYR_WALLET_PASSPHRASE env (env preferred — keeps phrase out of shell history). Interactive prompt on TTY when neither set.' },
         { flag: '--session-only', desc: 'OPT OUT of the passphrase fallback. Wallet is bound to this machine\'s OS keychain — dies on reboot/keyring loss/migration.', hint: 'use only for ephemeral / throwaway wallets where loss is acceptable' },
@@ -241,7 +241,6 @@ const WALLET_HELP = {
     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' },
@@ -449,6 +448,15 @@ const PHONE_HELP = {
         { flag: '(price)', desc: '$0.02 per call' },
         { flag: '(example)', desc: 'palmyr phone messages --id PN_abc' },
     ],
+    message: [
+        { flag: '--id <MESSAGE_ID>', desc: 'SMS message id (Telnyx-supplied; positional also accepted)' },
+        { flag: '(price)', desc: '$0.005 per readback — cheap so agents can poll until delivery_status is terminal' },
+        { flag: '(example)', desc: 'palmyr phone message <message-id-from-sms-response>' },
+    ],
+    'sms-status': [
+        { flag: '<message-id>', desc: 'Alias for `palmyr phone message <id>` — readback by id' },
+        { flag: '(price)', desc: '$0.005 per readback' },
+    ],
     calls: [
         { flag: '--id <PHONE_ID>', desc: 'Phone number id to list calls for (required; positional also accepted)' },
         { flag: '(price)', desc: '$0.02 per call' },
@@ -527,7 +535,7 @@ 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: '--wallet <id|name|sol_pubkey>', desc: 'Inbox owner — vault id/name (resolves to its Solana address) or a raw Solana pubkey. Omit to use the paying wallet.', hint: 'E2E encryption is Ed25519, so the owner must always be a Solana address — Base addresses cannot own an inbox' },
         { flag: '(price)', desc: '$2.00 per inbox provisioned' },
         { flag: '(example)', desc: 'palmyr email create --name agent --domain example.com' },
     ],
@@ -733,6 +741,337 @@ const CHAT_HELP = {
         { flag: '(example)', desc: 'palmyr chat providers --capability web_search' },
     ],
 };
+// Help tables for the two social subsystems. Their presence is what gates
+// `--help` from dispatching paid actions — see the `case 'twitter'` and
+// `case 'tiktok'` blocks below. 1.8.3 had no entries here and the
+// `case 'buy'` arm immediately called the $5 paid endpoint when a user
+// (reasonably) ran `palmyr twitter buy --help`. Every entry below MUST
+// flag the price for paid subcommands so future readers can scan it.
+const TWITTER_HELP = {
+    import: [
+        { flag: '<username>', desc: 'Twitter handle to import' },
+        { flag: '--credentials-line "..."', desc: 'login:password:email:email_pw:totp_seed:ct0:auth_token format' },
+        { flag: '--username --password ...', desc: 'Alternative: individual flags for each field' },
+        { flag: '(price)', desc: 'Free — local vault only' },
+    ],
+    list: [
+        { flag: '--local', desc: 'Skip server check; show only locally-vaulted accounts' },
+        { flag: '(price)', desc: 'Free local listing + paid lookups when --local is omitted (~$0.001 to enumerate server-side access)' },
+    ],
+    info: [
+        { flag: '<username>', desc: 'Account to inspect' },
+        { flag: '(price)', desc: 'Free — local vault read' },
+    ],
+    rename: [
+        { flag: '<old>', desc: 'Current local handle' },
+        { flag: '--to <new>', desc: 'New handle (after a real-server rename)' },
+        { flag: '(price)', desc: 'Free — local-only metadata update' },
+    ],
+    remove: [
+        { flag: '<username>', desc: 'Account to remove' },
+        { flag: '--confirm', desc: 'Required — local delete is irreversible' },
+        { flag: '(price)', desc: 'Free — local vault only' },
+    ],
+    totp: [
+        { flag: '<username>', desc: 'Account whose current TOTP code to print' },
+        { flag: '(price)', desc: 'Free — local TOTP generation' },
+    ],
+    buy: [
+        { flag: '(no args)', desc: 'Purchase the oldest ready X account from the supplier pool. Default for every filter below is random.' },
+        { flag: '--country <CC>', desc: 'Filter to a specific country (ISO alpha-2: US, GB, DE, …). Run `pool-prices` first to see what is priced.' },
+        { flag: '--source web|mobile', desc: 'Filter by registration source from X about-profile. Multiplies country price by source multiplier (default 1.0).' },
+        { flag: '--max-renames N', desc: 'Cap username-change count. --max-renames 0 = never renamed. NULL on row means unknown → does not match.' },
+        { flag: '--age 1y|2y|...', desc: 'Optional age category filter' },
+        { flag: '(price)', desc: '$5 USDC default; country_price * source_multiplier when filters are passed.' },
+        { flag: '(example)', desc: 'palmyr twitter buy --country US --source web --max-renames 0' },
+    ],
+    login: [
+        { flag: '<username>', desc: 'Force a fresh server-side session (browser runtime)' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+    'manual-login': [
+        { flag: '<username>', desc: 'Open a remote browser session you sign in to manually' },
+        { flag: '(price)', desc: 'Variable — server-side browser session cost' },
+    ],
+    session: [
+        { flag: '<username>', desc: 'Inspect cached server-side session status' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    post: [
+        { flag: '<username>', desc: 'Account to post from' },
+        { flag: '--body "..."', desc: 'Tweet body (required)' },
+        { flag: '(price)', desc: '$0.001 USDC per post' },
+    ],
+    reply: [
+        { flag: '<username>', desc: 'Account to reply from' },
+        { flag: '--to <url>', desc: 'Tweet URL to reply to' },
+        { flag: '--body "..."', desc: 'Reply body' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    like: [
+        { flag: '<username>', desc: 'Account doing the like' },
+        { flag: '--tweet <url>', desc: 'Tweet to like' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    retweet: [
+        { flag: '<username>', desc: 'Account doing the retweet' },
+        { flag: '--tweet <url>', desc: 'Tweet to retweet' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    follow: [
+        { flag: '<username>', desc: 'Account doing the follow' },
+        { flag: '--user @handle', desc: 'User to follow' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    unfollow: [
+        { flag: '<username>', desc: 'Account doing the unfollow' },
+        { flag: '--user @handle', desc: 'User to unfollow' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    delete: [
+        { flag: '<username>', desc: 'Account that posted the tweet' },
+        { flag: '--tweet <url>', desc: 'Tweet to delete' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    'list-tweets': [
+        { flag: '<username>', desc: 'Account whose timeline to fetch' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    bio: [
+        { flag: '<username>', desc: 'Account whose bio to update' },
+        { flag: '--text "..."', desc: 'New bio (<=160 chars)' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    name: [
+        { flag: '<username>', desc: 'Account whose display name to update' },
+        { flag: '--display "..."', desc: 'New display name' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    location: [
+        { flag: '<username>', desc: 'Account whose location to update' },
+        { flag: '--location "..."', desc: 'New location string' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    website: [
+        { flag: '<username>', desc: 'Account whose profile website to update' },
+        { flag: '--url https://...', desc: 'New website URL' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    pfp: [
+        { flag: '<username>', desc: 'Account whose avatar to update' },
+        { flag: '--file pic.png', desc: 'Image file (jpeg / png)' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+    banner: [
+        { flag: '<username>', desc: 'Account whose banner to update' },
+        { flag: '--file banner.png', desc: 'Image file' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+    username: [
+        { flag: '<username>', desc: 'Current account handle' },
+        { flag: '--to <new>', desc: 'New handle' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+    transfer: [
+        { flag: '<username>', desc: 'Account to transfer' },
+        { flag: '--to <wallet>', desc: 'Destination wallet address' },
+        { flag: '--confirm', desc: 'Required — rotates password, revokes other sessions' },
+        { flag: '(price)', desc: 'Free for vaulted accounts; ~$0.01 USDC to auto-register an imported-only account first' },
+    ],
+    share: [
+        { flag: '<username>', desc: 'Account to share' },
+        { flag: '--with <wallet>', desc: 'Wallet to grant access to' },
+        { flag: '(price)', desc: 'Free for shared access (no password rotation)' },
+    ],
+    unshare: [
+        { flag: '<username>', desc: 'Account to revoke share on' },
+        { flag: '--from <wallet>', desc: 'Wallet to revoke' },
+        { flag: '--rotate', desc: 'Also rotate password so cached cookies stop working' },
+        { flag: '(price)', desc: 'Free; --rotate runs async like transfer (~30-90s)' },
+    ],
+    claim: [
+        { flag: '(no args)', desc: 'Pull every server-side X account the wallet can access into the local vault' },
+        { flag: '(price)', desc: '~$0.001 USDC per account claimed (creds-decryption fee)' },
+    ],
+    // Server-backed account registration. Without these entries, `palmyr twitter
+    // register --help` (and friends) fell through to the top-level menu instead
+    // of explaining their flags. Subcommands listed in the parent switch must
+    // always have an entry here so the help guard fires before the case body.
+    thread: [
+        { flag: '<username>', desc: 'Account to post the thread from' },
+        { flag: '--texts \'["...","..."]\'', desc: 'JSON array of tweets (in order)' },
+        { flag: '--file path.json', desc: 'Alternative: read the JSON array from a file' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+    register: [
+        { flag: '<username>', desc: 'Account handle' },
+        { flag: '--password <pw>', desc: 'Required if the account is not already in the local vault' },
+        { flag: '--login --email --totp-seed --auth-token --ct0', desc: 'Optional; auto-pulled from local vault when not passed' },
+        { flag: '--country <CC>', desc: 'Optional residency hint stored alongside the encrypted credentials' },
+        { flag: '(price)', desc: 'Free — server tests login + encrypts creds at rest. Enables scheduling.' },
+    ],
+    unregister: [
+        { flag: '<username-or-id>', desc: 'Handle or 32-char hex account id' },
+        { flag: '(price)', desc: 'Free — wipes server-side credentials, account no longer schedulable' },
+    ],
+    registered: [
+        { flag: '(no args)', desc: 'List every server-registered X account this wallet owns' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    schedule: [
+        { flag: '<username>', desc: 'Account to post from (must be `register`-ed)' },
+        { flag: '--at "ISO8601"', desc: 'When to fire (e.g. --at "2026-05-15T14:00:00Z")' },
+        { flag: '--body "..."', desc: 'Text-only post' },
+        { flag: '--texts \'["..."]\' / --file path.json', desc: 'Thread' },
+        { flag: '--image / --video / --media-json', desc: 'Media attachments' },
+        { flag: '--community <id>', desc: 'Post into an X Community' },
+        { flag: '(price)', desc: '$0.001 USDC (text) or $0.005 USDC (thread / media) — paid up front' },
+    ],
+    queue: [
+        { flag: '--status pending|in_progress|completed|failed|cancelled', desc: 'Filter by status' },
+        { flag: '--from / --to "ISO8601"', desc: 'Filter by post-at window' },
+        { flag: '--account-id <id>', desc: 'Filter to one account' },
+        { flag: '--limit <n>', desc: 'Cap result count' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    cancel: [
+        { flag: '<schedule-id>', desc: 'Id from `palmyr twitter queue`' },
+        { flag: '(price)', desc: 'Free — only cancels pending posts; in-flight ones are already settled' },
+    ],
+    status: [
+        { flag: '<username>', desc: 'Account to inspect' },
+        { flag: '(price)', desc: 'Server-side liveness/shadow-ban check (not yet wired — see `palmyr twitter session` for cached login state)' },
+    ],
+    'pool-add': [
+        { flag: '--credentials-line "..."', desc: 'Single account creds (login:pw:email:email_pw[:2fa[:ct0:auth_token]])' },
+        { flag: '--file path.txt', desc: 'Bulk: one credentials-line per row (# = comment)' },
+        { flag: '--price <USDC>', desc: 'Required — per-account sale_price_usdc (legacy fallback when no country price row exists)' },
+        { flag: '--country <CC>', desc: 'Optional override; twitterapi.io detects country + source + rename count from about_profile at seed time. Admin wins on country mismatch (flagged in response).' },
+        { flag: '--age 1y|2y|3y|...', desc: 'Optional age category metadata' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free — server-side seeding by pool operator' },
+    ],
+    'pool-prices': [
+        { flag: '(no args)', desc: 'List per-country prices set by the pool admin (public, free).' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'pool-set-price': [
+        { flag: '--country <CC>', desc: 'ISO 3166-1 alpha-2 country code (US, GB, DE, …)' },
+        { flag: '--price <USDC>', desc: 'USDC amount the `buy --country <CC>` route will charge' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'pool-delete-price': [
+        { flag: '--country <CC>', desc: 'Country code to remove pricing for' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'pool-set-source-multiplier': [
+        { flag: '--source web|mobile|<id>', desc: 'Source identifier (matches the `source` column populated by twitterapi.io)' },
+        { flag: '--multiplier <number>', desc: 'Positive scaling factor applied on top of country price when --source is passed at buy time. 1.0 = no change.' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'pool-delete-source-multiplier': [
+        { flag: '--source <id>', desc: 'Source identifier to remove the multiplier for (buy still works, just reverts to multiplier=1.0)' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    dispute: [
+        { flag: '<account_id>', desc: 'Account id returned by `twitter buy` (the 32-char hex)' },
+        { flag: '--reason suspended|other', desc: 'Default "suspended" — triggers auto-verify via twitterapi.io' },
+        { flag: '--evidence "..."', desc: 'Optional note shown to the admin if the dispute ends up in admin_review' },
+        { flag: '(price)', desc: '$0.01 USDC ownership-proof. 7-day window from purchase.' },
+        { flag: '(example)', desc: 'palmyr twitter dispute abcd1234… --reason suspended' },
+    ],
+    disputes: [
+        { flag: '<dispute_id>', desc: 'Look up the status of a previously filed dispute' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    'pool-disputes': [
+        { flag: '(no args)', desc: 'List every dispute in the system (admin)' },
+        { flag: '--status admin_review|pending|replaced|refunded|rejected', desc: 'Filter by status' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'pool-resolve-dispute': [
+        { flag: '<dispute_id>', desc: 'Id from `pool-disputes`' },
+        { flag: '--action replace|refund|reject', desc: 'replace = grant same-country swap; refund = USDC back to payer; reject = decline' },
+        { flag: '--note "..."', desc: 'Optional admin note appended to the resolution' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    'pool-status': [
+        { flag: '(no args)', desc: 'Available / sold / reserved counts in the X account pool' },
+        { flag: '(auth)', desc: 'Admin-signed call — requires PALMYR_ADMIN_KEY' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+};
+const TIKTOK_HELP = {
+    import: [
+        { flag: '<username>', desc: 'TikTok handle to import' },
+        { flag: '--sessionid <s> --csrf <c> --webid <w>', desc: 'Cookies from a logged-in TikTok browser' },
+        { flag: '--credentials-line "..."', desc: 'Marketplace login:pw:email:email_pw format' },
+        { flag: '(price)', desc: 'Free — local vault only' },
+    ],
+    list: [
+        { flag: '(no args)', desc: 'List all local TikTok accounts' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    info: [{ flag: '<username>', desc: 'Show one account' }, { flag: '(price)', desc: 'Free' }],
+    rename: [
+        { flag: '<old>', desc: 'Current local handle' },
+        { flag: '--to <new>', desc: 'New handle' },
+        { flag: '(price)', desc: 'Free — local-only metadata update' },
+    ],
+    remove: [
+        { flag: '<username>', desc: 'Account to delete from local vault' },
+        { flag: '--confirm', desc: 'Required' },
+        { flag: '(price)', desc: 'Free' },
+    ],
+    totp: [{ flag: '<username>', desc: 'Print current TOTP code' }, { flag: '(price)', desc: 'Free' }],
+    login: [
+        { flag: '<username>', desc: 'Validate cookies and cache the session' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+    session: [{ flag: '<username>', desc: 'Check cached session' }, { flag: '(price)', desc: 'Free' }],
+    post: [
+        { flag: '<username>', desc: 'Account to post from' },
+        { flag: '--file video.mp4', desc: 'Video file' },
+        { flag: '--caption "..."', desc: 'Caption' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    follow: [
+        { flag: '<username>', desc: 'Account doing the follow' },
+        { flag: '--user @handle', desc: 'User to follow' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    like: [
+        { flag: '<username>', desc: 'Account doing the like' },
+        { flag: '--video <url>', desc: 'Video URL to like' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    delete: [
+        { flag: '<username>', desc: 'Account that posted the video' },
+        { flag: '--video <url>', desc: 'Video to delete' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    bio: [
+        { flag: '<username>', desc: 'Account whose bio to update' },
+        { flag: '--text "..."', desc: 'New bio (<=80 chars)' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    name: [
+        { flag: '<username>', desc: 'Account whose display name to update' },
+        { flag: '--display "..."', desc: 'New display name (<=30 chars)' },
+        { flag: '(price)', desc: '$0.001 USDC' },
+    ],
+    pfp: [
+        { flag: '<username>', desc: 'Account whose avatar to update' },
+        { flag: '--file pic.png', desc: 'Image file' },
+        { flag: '(price)', desc: '$0.005 USDC' },
+    ],
+};
 /**
  * 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
@@ -849,6 +1188,7 @@ const TOP_LEVEL_COMMANDS = [
     { name: 'doctor', description: 'Verify system health (cred store, vault, API)' },
     { name: 'pricing', description: 'All service prices' },
     { name: 'health', description: 'API status + version check' },
+    { name: 'telemetry', description: 'on · off · status (opt-in anonymous usage stats)' },
 ];
 // ─── Help ───
 function help() {
@@ -942,6 +1282,22 @@ async function main() {
     const startTime = Date.now();
     // No first-time banner — agent-first CLI should never pollute output.
     const url = process.env.PALMYR_API || config.api;
+    // Opt-in telemetry. If the user has explicitly enabled it, queue this run's
+    // exit-code + duration on shutdown (sync — async work in 'exit' is dropped)
+    // and fire-and-forget any previously-queued events to the API right now.
+    // Both no-ops when telemetry is off. Never blocks the user's command —
+    // the flush races their work and Node exits once both finish.
+    process.on('exit', (code) => {
+        telemetryAppendEvent({
+            cmd: subcommand ? `${command} ${subcommand}` : command,
+            exitCode: code,
+            durationMs: Date.now() - startTime,
+            cliVersion: VERSION,
+            nodeVersion: process.version,
+            platform: process.platform,
+        });
+    });
+    void telemetryFlushQueue(url);
     const token = flags.token || config.apiKey || process.env.PALMYR_TOKEN || process.env.PALMYR_API_KEY;
     const passphrase = flags.passphrase || process.env.PALMYR_WALLET_PASSPHRASE;
     const ao = new Palmyr(url, true, token, passphrase);
@@ -1042,6 +1398,7 @@ async function main() {
                             { 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: 'message', description: 'Get one SMS message by id (incl. delivery status)', hint: '--id MESSAGE_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' },
@@ -1149,6 +1506,18 @@ async function main() {
                         const data = await ao.phoneMessages(id);
                         return print(data);
                     }
+                    case 'message':
+                    case 'sms-status': {
+                        // Per-message readback. Mirrors `phone call-info` for SMS:
+                        // the Telnyx webhook updates delivery_status on the row, and this
+                        // endpoint serves it back. Useful when the immediate sms response
+                        // is 'queued' and the caller wants to confirm delivery.
+                        const messageId = flags.id || flags.message || positional[0];
+                        if (!messageId)
+                            err('Usage: palmyr phone message <message-id>');
+                        const data = await ao.phoneMessage(messageId);
+                        return print(data);
+                    }
                     case 'calls': {
                         const id = flags.id || positional[0];
                         if (!id)
@@ -1287,13 +1656,58 @@ async function main() {
                 switch (subcommand) {
                     case 'create': {
                         const name = flags.name || positional[0];
-                        const wallet = flags.wallet;
+                        const walletInput = flags.wallet;
                         const domain = flags.domain;
                         if (!name)
                             err('--name required (e.g. palmyr email create --name hello [--domain example.com])');
+                        // --wallet accepts three forms: vault id, vault name, or a raw
+                        // Solana base58 pubkey. The server only accepts a Solana pubkey
+                        // (E2E encryption is Ed25519→X25519), so resolve id/name to a
+                        // pubkey here before the request. Raw pubkeys pass through.
+                        // Doing this resolution client-side also means a Base-paying user
+                        // doesn't need a Solana wallet — their vault already has one
+                        // (single mnemonic, both chains), and we can find it without
+                        // making the server reach back for client-side keys.
+                        let walletAddress;
+                        if (walletInput) {
+                            const looksLikeSolPubkey = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(walletInput);
+                            if (looksLikeSolPubkey) {
+                                walletAddress = walletInput;
+                            }
+                            else {
+                                const { listVaultWallets } = await import('./vault.js');
+                                const wallets = listVaultWallets();
+                                const match = wallets.find(w => w.id === walletInput || w.name === walletInput);
+                                if (!match)
+                                    err(`--wallet "${walletInput}" did not match any vault id, name, or look like a Solana pubkey`);
+                                if (!match.solanaAddress)
+                                    err(`Wallet "${walletInput}" has no Solana address — email inboxes require one (E2E uses Ed25519). Re-create with: palmyr wallet create`);
+                                walletAddress = match.solanaAddress;
+                            }
+                        }
+                        else {
+                            // No --wallet: the server would normally default the inbox owner
+                            // to the x402 payer. That works for Solana-paid calls but
+                            // 400s on Base because the payer is an EVM address. Auto-fill
+                            // the *paying wallet's* Solana address here so a single
+                            // mnemonic-derived vault wallet works on either pay chain.
+                            const cfg = loadConfig();
+                            const payChain = (cfg.defaultPayChain || 'solana');
+                            if (payChain === 'base') {
+                                const { listVaultWallets } = await import('./vault.js');
+                                const wallets = listVaultWallets();
+                                const targetId = cfg.defaultPayWalletId || process.env.PALMYR_PAY_WALLET;
+                                const paying = (targetId && wallets.find(w => w.id === targetId)) || wallets.find(w => w.evmAddress && w.solanaAddress);
+                                if (paying?.solanaAddress)
+                                    walletAddress = paying.solanaAddress;
+                                // If no Solana address is reachable, fall through and let the
+                                // server return its actionable 400 — silent failure would be
+                                // worse than a clear error.
+                            }
+                        }
                         const spin = new Spinner();
                         spin.start('Creating inbox...');
-                        const data = await ao.emailCreate(name, wallet, domain);
+                        const data = await ao.emailCreate(name, walletAddress, domain);
                         spin.stop('Inbox created', true);
                         return print(data);
                     }
@@ -1589,6 +2003,26 @@ async function main() {
                         const localKeyPath = generatedKeyMeta?.privateKeyPath
                             || (pubkeyFile ? pubkeyFile.replace(/\.pub$/, '').replace('~', homedir()) : undefined)
                             || (explicitKeyPath ? explicitKeyPath.replace('~', homedir()) : undefined);
+                        // --ssh-key <id> uploads a server-side key but doesn't tell us where
+                        // the matching private key lives on this machine. Without
+                        // --key-path, the SSH readiness gate later silently skips and the
+                        // deploy reports `ssh: skipped` while still marking the server as
+                        // "ready" — a real foot-gun (dogfood report 2026-05-25 hit this
+                        // exact path). Be loud about it now, before anyone pays.
+                        if (sshKeyIds && !localKeyPath) {
+                            const msg = 'Warning: --ssh-key <id> uploaded the public key server-side, ' +
+                                'but no matching private key was passed to this CLI. ' +
+                                'SSH readiness cannot be verified locally — `compute wait` and the ' +
+                                'inline --wait check will skip the SSH gate. Pass ' +
+                                '`--key-path /path/to/private_key` (or `--private-key`) to ' +
+                                'enable the verification.';
+                            if (AGENT_MODE) {
+                                process.stderr.write(JSON.stringify({ event: 'warning', code: 'ssh_key_no_local_key', message: msg }) + '\n');
+                            }
+                            else {
+                                process.stderr.write(`\n${msg}\n\n`);
+                            }
+                        }
                         // Progress events to stderr — default ON in agent mode so a
                         // long deploy isn't a 10-minute silence. Pass --no-progress to
                         // opt out. Stdout still gets one final JSON object, so jq
@@ -2169,7 +2603,7 @@ async function main() {
                         subtitle: 'Non-custodial HD wallet',
                         footerLeft: 'Solana + Base wallet operations',
                         commands: [
-                            { name: 'create', description: 'Create one or many wallets', hint: '[--tag X --count 100] [--solana|--base] [--managed]' },
+                            { name: 'create', description: 'Create one or many wallets', hint: '[--tag X --count 100] [--solana|--base]' },
                             { 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' },
@@ -2183,7 +2617,6 @@ async function main() {
                             { name: 'api-key', description: 'Create agent API key', hint: 'WALLET_ID --name my-agent' },
                             { name: 'config', description: 'Get agent config', hint: 'WALLET_ID' },
                             { name: 'use', description: 'Set default pay wallet', hint: 'WALLET_ID' },
-                            { name: 'request-approval', description: 'Request human approval (managed)', hint: 'WALLET_ID --action limits --daily 100' },
                             { name: 'buy', description: 'Open a trading position', hint: 'solana <CA> --amount 0.5sol --thesis "..."' },
                             { name: 'cohort', description: 'Split a buy across N derived wallets with jitter (Phase 4c)', hint: 'buy <CHAIN> <CA> --total ... --split N' },
                             { name: 'template', description: 'Manage YAML strategy templates', hint: 'list | show <name> | path <name> | delete <name>' },
@@ -4978,7 +5411,12 @@ async function main() {
                     log(`auto-imported @${username} from server (${sourceLabel} → local vault)`);
                     return summary;
                 };
-                if (!subcommand) {
+                // Help guard. `palmyr twitter buy --help` MUST never dispatch to the
+                // paid `case 'buy'` below — 1.8.3 had no guard here and a real user
+                // got charged $5 for a help command. Falls back to the top-level menu
+                // when the subcommand has no per-subcommand help entry, so even an
+                // unrecognized `palmyr twitter <whatever> --help` is safe to run.
+                if (!subcommand || (flags.help && !TWITTER_HELP[subcommand])) {
                     showMenu({
                         command: 'twitter',
                         title: 'twitter',
@@ -4994,7 +5432,10 @@ async function main() {
                             { name: 'buy', description: 'Purchase an aged account (requires server supplier config)', hint: '--age 1y --country US' },
                             { 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>' },
+                            // `status` is not wired yet (Phase 3). Hidden from this menu so
+                            // users don't try a command that will only error; `session`
+                            // covers the most useful subset (cached server-side login state).
+                            { name: 'session', description: 'Inspect cached server-side session for an account', hint: '<username>' },
                             { 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]' },
@@ -5004,6 +5445,10 @@ async function main() {
                     });
                     return;
                 }
+                if (flags.help && subcommand && TWITTER_HELP[subcommand]) {
+                    subcommandHelp('twitter', subcommand, TWITTER_HELP[subcommand]);
+                    return;
+                }
                 switch (subcommand) {
                     case 'import': {
                         // Option 1: --credentials-line "login:password:email:email_pw:2fa:ct0:auth_token"
@@ -5829,10 +6274,27 @@ async function main() {
                         return print({ success: true, platform, username, op: subcommand, ...(data?.data || {}) });
                     }
                     case 'buy': {
-                        // Agents just say "buy." Server picks the oldest ready account.
+                        // Agents say "buy" with optional --country / --source / --max-renames.
+                        // Each filter is independent (default: random across that
+                        // dimension). Pricing = country_price * source_multiplier:
+                        //   - --country US               → country_prices.US (e.g. $8)
+                        //   - --source web               → multiplied by web's row in
+                        //                                  source_multipliers (e.g. 1.2)
+                        //   - --max-renames 0            → filter only, no price impact
+                        // Without --country, falls back to the legacy $5 flat rate.
+                        const country = (flags.country || '').trim().toUpperCase() || undefined;
+                        const ageCategory = flags.age || flags['age-category'] || undefined;
+                        const source = (flags.source || '').trim().toLowerCase() || undefined;
+                        const maxRenamesRaw = flags['max-renames'];
+                        const maxUsernameChanges = maxRenamesRaw === undefined || maxRenamesRaw === ''
+                            ? undefined
+                            : Number(maxRenamesRaw);
+                        if (maxUsernameChanges !== undefined && (!Number.isFinite(maxUsernameChanges) || maxUsernameChanges < 0)) {
+                            err('--max-renames must be a non-negative integer (e.g. 0 = never renamed)');
+                        }
                         let data;
                         try {
-                            data = await ao.socialTwitterBuy();
+                            data = await ao.socialTwitterBuy(country, ageCategory, { source, maxUsernameChanges });
                         }
                         catch (e) {
                             err(`Buy failed: ${e.message}`, EXIT.GENERAL);
@@ -5844,10 +6306,15 @@ async function main() {
                         // Auto-import into the local vault + prime the session cache so
                         // the buyer can post immediately with the cookies the admin
                         // pre-seasoned at pool-add time.
+                        const filterTags = [
+                            country && `country=${country}`,
+                            source && `source=${source}`,
+                            maxUsernameChanges !== undefined && `max_renames=${maxUsernameChanges}`,
+                        ].filter(Boolean).join(', ');
                         const summary = sv.importAccount(platform, account.username, account.credentials, {
                             source: 'pool',
                             proxy_session_id: account.proxy_session_id,
-                            notes: 'Bought from pool',
+                            notes: filterTags ? `Bought from pool (${filterTags})` : 'Bought from pool',
                         });
                         sv.saveSession(summary.id, platform, account.cookies || []);
                         sv.updateMeta(platform, summary.username, { last_action_at: new Date().toISOString() });
@@ -5855,8 +6322,177 @@ async function main() {
                             success: true,
                             platform,
                             username: summary.username,
-                            hint: `Ready to post — try: palmyr twitter post ${summary.username} --body "gm"`,
+                            country: account.country,
+                            source: account.source,
+                            username_change_count: account.username_change_count,
+                            account_based_in: account.account_based_in,
+                            account_id: account.id,
+                            hint: `Ready to post — try: palmyr twitter post ${summary.username} --body "gm". ` +
+                                `If the account is suspended within 7 days, run: palmyr twitter dispute ${account.id}`,
+                        });
+                    }
+                    case 'pool-prices': {
+                        // Public: which countries are priced and what they cost. Run
+                        // before `buy --country X` to confirm the country is available.
+                        let data;
+                        try {
+                            data = await ao.socialTwitterPoolPrices();
+                        }
+                        catch (e) {
+                            err(`pool-prices failed: ${e.message}`, EXIT.GENERAL);
+                        }
+                        return print(data);
+                    }
+                    case 'pool-set-price': {
+                        // Admin: set USDC price for a single country code. Idempotent.
+                        const { buildAdminHeaders } = await import('./admin-auth.js');
+                        const country = (flags.country || '').trim().toUpperCase();
+                        const price = flags.price !== undefined ? Number(flags.price) : NaN;
+                        if (!country)
+                            err('--country <CC> required (ISO 3166-1 alpha-2: US, GB, DE, …)');
+                        if (!Number.isFinite(price) || price <= 0)
+                            err('--price <USDC> required (positive number)');
+                        const path = `/social/twitter/pool/prices/${encodeURIComponent(country)}`;
+                        const headers = buildAdminHeaders('PUT', path);
+                        const res = await fetch(ao.api + path, {
+                            method: 'PUT',
+                            headers: { 'Content-Type': 'application/json', ...headers },
+                            body: JSON.stringify({ price_usdc: price }),
                         });
+                        const data = await res.json();
+                        if (!res.ok || !data.success)
+                            err(`pool-set-price failed: ${data.error || `HTTP ${res.status}`}`, EXIT.GENERAL);
+                        return print(data);
+                    }
+                    case 'pool-delete-price': {
+                        // Admin: remove the row for a country. Subsequent `buy --country X`
+                        // will return 400 "Country not priced" until set again.
+                        const { buildAdminHeaders } = await import('./admin-auth.js');
+                        const country = (flags.country || '').trim().toUpperCase();
+                        if (!country)
+                            err('--country <CC> required');
+                        const path = `/social/twitter/pool/prices/${encodeURIComponent(country)}`;
+                        const headers = buildAdminHeaders('DELETE', path);
+                        const res = await fetch(ao.api + path, { method: 'DELETE', headers });
+                        const data = await res.json();
+                        if (!res.ok)
+                            err(`pool-delete-price failed: ${data.error || `HTTP ${res.status}`}`, EXIT.GENERAL);
+                        return print(data);
+                    }
+                    case 'pool-set-source-multiplier': {
+                        // Admin: scale the country price for buys filtered by a given
+                        // source ('web', 'mobile', …). e.g. mult=1.2 → web buys cost
+                        // 20% more than the base country price.
+                        const { buildAdminHeaders } = await import('./admin-auth.js');
+                        const source = (flags.source || '').trim().toLowerCase();
+                        const mult = flags.multiplier !== undefined ? Number(flags.multiplier) : NaN;
+                        if (!source)
+                            err('--source <name> required (e.g. web, mobile)');
+                        if (!Number.isFinite(mult) || mult <= 0)
+                            err('--multiplier <number> required (positive)');
+                        const path = `/social/twitter/pool/source-multipliers/${encodeURIComponent(source)}`;
+                        const headers = buildAdminHeaders('PUT', path);
+                        const res = await fetch(ao.api + path, {
+                            method: 'PUT',
+                            headers: { 'Content-Type': 'application/json', ...headers },
+                            body: JSON.stringify({ multiplier: mult }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok || !data.success)
+                            err(`pool-set-source-multiplier failed: ${data.error || `HTTP ${res.status}`}`, EXIT.GENERAL);
+                        return print(data);
+                    }
+                    case 'pool-delete-source-multiplier': {
+                        // Admin: drop the multiplier for a source. Subsequent `buy
+                        // --source X` reverts to using 1.0 (filter only, no price scaling).
+                        const { buildAdminHeaders } = await import('./admin-auth.js');
+                        const source = (flags.source || '').trim().toLowerCase();
+                        if (!source)
+                            err('--source <name> required');
+                        const path = `/social/twitter/pool/source-multipliers/${encodeURIComponent(source)}`;
+                        const headers = buildAdminHeaders('DELETE', path);
+                        const res = await fetch(ao.api + path, { method: 'DELETE', headers });
+                        const data = await res.json();
+                        if (!res.ok)
+                            err(`pool-delete-source-multiplier failed: ${data.error || `HTTP ${res.status}`}`, EXIT.GENERAL);
+                        return print(data);
+                    }
+                    case 'dispute': {
+                        // Buyer: file a dispute for a pool-bought account that got
+                        // suspended. Server auto-verifies via twitterapi.io and either
+                        // hands over a same-country replacement, refunds USDC, or queues
+                        // for admin review when the signal is ambiguous.
+                        const accountId = positional[0] || flags['account-id'] || flags.id;
+                        const reason = (flags.reason || 'suspended');
+                        const evidence = flags.evidence || flags.note || undefined;
+                        if (!accountId)
+                            err('<account_id> required (the id returned by `palmyr twitter buy`)');
+                        if (reason !== 'suspended' && reason !== 'other')
+                            err('--reason must be "suspended" or "other"');
+                        let data;
+                        try {
+                            data = await ao.socialTwitterDispute(accountId, { reason, evidence });
+                        }
+                        catch (e) {
+                            err(`Dispute failed: ${e.message}`, EXIT.GENERAL);
+                        }
+                        if (!data?.success)
+                            err(`Dispute failed: ${data?.error || 'unknown'}`, EXIT.GENERAL);
+                        return print(data);
+                    }
+                    case 'disputes': {
+                        // Buyer: list ONE specific dispute by id. Listing all your
+                        // disputes isn't supported by the buyer surface today — track
+                        // the id printed by `dispute` and call `disputes <id>`.
+                        const id = positional[0] || flags.id;
+                        if (!id)
+                            err('<dispute_id> required');
+                        let data;
+                        try {
+                            data = await ao.socialTwitterDisputeGet(id);
+                        }
+                        catch (e) {
+                            err(`Get dispute failed: ${e.message}`, EXIT.GENERAL);
+                        }
+                        return print(data);
+                    }
+                    case 'pool-disputes': {
+                        // Admin: list every dispute, optionally filter by status. The
+                        // `admin_review` queue is the human-decision backlog.
+                        const { buildAdminHeaders } = await import('./admin-auth.js');
+                        const status = flags.status || undefined;
+                        const path = '/social/twitter/pool/disputes' + (status ? `?status=${encodeURIComponent(status)}` : '');
+                        const headers = buildAdminHeaders('GET', path);
+                        const res = await fetch(ao.api + path, { headers });
+                        const data = await res.json();
+                        if (!res.ok)
+                            err(`pool-disputes failed: ${data.error || `HTTP ${res.status}`}`, EXIT.GENERAL);
+                        return print(data);
+                    }
+                    case 'pool-resolve-dispute': {
+                        // Admin: resolve an admin_review dispute. action ∈ replace |
+                        // refund | reject. `replace` needs same-country stock; `refund`
+                        // needs payment provenance on the row (auto-saved at buy time).
+                        const { buildAdminHeaders } = await import('./admin-auth.js');
+                        const id = positional[0] || flags.id;
+                        const action = flags.action;
+                        const note = flags.note || undefined;
+                        if (!id)
+                            err('<dispute_id> required');
+                        if (action !== 'replace' && action !== 'refund' && action !== 'reject') {
+                            err('--action must be "replace", "refund", or "reject"');
+                        }
+                        const path = `/social/twitter/pool/disputes/${encodeURIComponent(id)}/resolve`;
+                        const headers = buildAdminHeaders('POST', path);
+                        const res = await fetch(ao.api + path, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json', ...headers },
+                            body: JSON.stringify({ action, ...(note ? { note } : {}) }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok || !data.success)
+                            err(`pool-resolve-dispute failed: ${data.error || `HTTP ${res.status}`}`, EXIT.GENERAL);
+                        return print(data);
                     }
                     case 'pool-add': {
                         const { buildAdminHeaders } = await import('./admin-auth.js');
@@ -5941,14 +6577,22 @@ async function main() {
                         return print(data);
                     }
                     case 'status': {
-                        err(`twitter status: not wired yet. Phase 3 will add it.`, EXIT.GENERAL);
+                        // `twitter status` was meant to check live shadow-ban / suspension
+                        // state via a server-side probe. That's a Phase 3 build (needs a
+                        // browser runtime on the server to render the profile). Until
+                        // then, point users at `session` for the cached login state and
+                        // `info` for vault metadata — together they cover the practical
+                        // "is this account still usable from the agent's side" question.
+                        err(`twitter status: not wired yet (Phase 3). Closest equivalents available today: ` +
+                            `\`palmyr twitter session <username>\` (cached server-side login validity) and ` +
+                            `\`palmyr twitter info <username>\` (local vault record).`, EXIT.GENERAL);
                     }
                     case 'transfer': {
                         // 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).
+                        //      ($0.01 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`.
@@ -6320,7 +6964,9 @@ async function main() {
             case 'tiktok': {
                 const sv = await import('./social-vault.js');
                 const platform = 'tiktok';
-                if (!subcommand) {
+                // Same help guard as `twitter` — prevents `--help` from dispatching
+                // a paid subcommand. Same bug class lived here too in 1.8.3.
+                if (!subcommand || (flags.help && !TIKTOK_HELP[subcommand])) {
                     showMenu({
                         command: 'tiktok',
                         title: 'tiktok',
@@ -6347,6 +6993,10 @@ async function main() {
                     });
                     return;
                 }
+                if (flags.help && subcommand && TIKTOK_HELP[subcommand]) {
+                    subcommandHelp('tiktok', subcommand, TIKTOK_HELP[subcommand]);
+                    return;
+                }
                 switch (subcommand) {
                     case 'import': {
                         // Two formats:
@@ -6693,6 +7343,55 @@ async function main() {
                     'The Palmyr server fires them at post_at without any client process.', EXIT.BAD_INPUT);
                 break;
             }
+            case 'telemetry': {
+                // Off by default. Opt-in only. We never auto-enable, never prompt at
+                // startup, never write to stdout outside this command. Captured fields
+                // and storage location are documented in cli/telemetry.ts.
+                const action = (subcommand || 'status').toLowerCase();
+                if (action !== 'on' && action !== 'off' && action !== 'status') {
+                    err(`Unknown telemetry action: ${action}. Use: on | off | status`, EXIT.BAD_INPUT);
+                }
+                let state;
+                if (action === 'on')
+                    state = setTelemetryEnabled(true);
+                else if (action === 'off')
+                    state = setTelemetryEnabled(false);
+                else
+                    state = getTelemetryState();
+                const payload = {
+                    enabled: state.enabled,
+                    installId: state.installId || null,
+                    optedInAt: state.optedInAt || null,
+                    queuedEvents: telemetryQueuedCount(),
+                    captures: ['cmd', 'exitCode', 'durationMs', 'cliVersion', 'nodeVersion', 'platform'],
+                    neverCaptures: ['flag values', 'positional args', 'stdout/stderr', 'wallet addresses', 'phone numbers', 'any user input'],
+                };
+                if (AGENT_MODE) {
+                    print(payload);
+                }
+                else {
+                    const status = state.enabled ? `${t.success}on${t.reset}` : `${t.muted}off${t.reset}`;
+                    console.log(`Telemetry:  ${status}`);
+                    if (state.installId)
+                        console.log(`Install ID: ${t.muted}${state.installId}${t.reset}`);
+                    if (state.optedInAt)
+                        console.log(`Opted in:   ${state.optedInAt}`);
+                    if (payload.queuedEvents)
+                        console.log(`Queued:     ${payload.queuedEvents} event(s) waiting to send`);
+                    console.log('');
+                    console.log(`Captures:   ${payload.captures.join(', ')}`);
+                    console.log(`Never:      flag values, positional args, stdout, user input`);
+                    if (!state.enabled) {
+                        console.log('');
+                        console.log(`Opt in:     ${t.accent}palmyr telemetry on${t.reset}`);
+                    }
+                    else {
+                        console.log('');
+                        console.log(`Opt out:    ${t.accent}palmyr telemetry off${t.reset}  (drops any queued events)`);
+                    }
+                }
+                break;
+            }
             case 'config': {
                 const cfg = loadConfig();
                 const { homedir } = await import('os');