--- name: using-politereach description: Overview of PoliteReach, the LinkedIn outreach connector. Says what must be connected for each job (the PoliteReach connector, a LinkedIn account, a calendar for bookings, an email connector for email follow-ups, scheduled tasks for routines), which PoliteReach skill handles which job, and what every li_* tool does with its safety rule. Use when the user asks what PoliteReach can do, how to use it, what they need to connect or set up, which tool or skill to use, why something needs a calendar or a subscription, or makes any PoliteReach request that no other PoliteReach skill covers. --- # Using PoliteReach PoliteReach sends LinkedIn outreach from the user's OWN LinkedIn accounts. You (the assistant) research, write and decide. PoliteReach's server does the LinkedIn work: invites, acceptance checks, prefilled messages, reading replies, accepting invitations, posts. Its tools are named `li_*`. ## What must be connected, per job | Job | Needs | If it is missing | |---|---|---| | Anything | The PoliteReach connector, signed in with the user's PoliteReach email | claude.ai, Desktop, Cowork: this plugin's **Connectors** tab. Claude Code: `/mcp`, pick `politereach`. ChatGPT or Codex: add `https://mcp.politereach.com/mcp`. No login yet: https://politereach.com | | Anything that touches LinkedIn | At least one LinkedIn account added on https://app.politereach.com (**Accounts**), signed in, and checked with `li_verify_account` | New account: add it on the Accounts page. Signed out or security check: `li_login_link`, give the user the link | | Sending, research, posting | A plan that covers the account (trial or paid) | Relay the refusal as it is. If it carries a link, give that link unchanged; never invent one | | Research (`li_research_profiles`, `li_enrich_profiles`, `li_enrich_company`) | Lookups left in the research allowance (shared across the owner's accounts) | `li_research_profiles` with `estimateOnly` first. Out of lookups: say so; `li_contact_dossier` still reads stored research for free | | Booking check (who booked), and the nudges that depend on it | A calendar connector in the SAME app: Google Calendar, or Microsoft 365 / Outlook calendar (a Calendly or Cal.com connector that lists bookings also works). Its list-events and get-event tools must be allowed | Tell the user to connect their calendar in the app's connector settings. Until then, record who agreed but say you cannot tell who booked, and send no nudges. Never guess | | Booking nudges | The account's booking link, set with `li_set_booking_settings` (`bookingUrls`; the pace is `nudgeScheduleDays`) | Ask for the link and set it on a yes. Without it no link is noticed as sent | | Warm follow-ups (chains, stages, the warm queue) | Nothing beyond the connector. An email connector in the same app (Gmail, Outlook…) only for email steps | No email connector: email steps come to the user as text to send themselves, then `li_log_touch`. Never suggest one to a user who follows up on LinkedIn only | | Routines that run on their own | The app's scheduled-tasks feature (claude.ai and Cowork: **Scheduled**; Claude Code: `/schedule`; ChatGPT: tasks), with the tools set to always allow | Run the routine by hand when the user asks | | Writing in the user's voice | The user's own outreach skill | The `outreach-skill-builder` skill | PoliteReach itself never connects to a calendar or a mailbox, and never sends email. You read and send those through the user's own connectors and tell PoliteReach only what is needed (attendee name, email, event id, times, description; an email touch with `li_log_touch`). ## Which skill for which job - Set up, connect or reconnect, account health: `get-started`. Everything in one go (account, outreach skill, routines): its `references/setup-sequence.md`. - Build the user's voice, ICPs and offers: `outreach-skill-builder`. - Reach out to people from LinkedIn links, or split a list into test arms: `start-outreach`. - Replies waiting on the user, outcomes, the follow-up chain after each reply: `answer-replies`. - Warm leads after a reply, a call or a proposal: follow-up chains, deal stages, email and call touches, the daily warm queue: `keep-warm-leads`. - Invitations people sent the user: `inbound-invitations`. - Who agreed to a call, who booked, nudges, how a call went: `book-agreed-calls`. - Posts now or later, a content calendar: `schedule-posts`. - How things are going, pending invites, do-not-contact: `pipeline-check`. - What goes out soon, fixing queued wording: `queued-messages`. Load the matching skill and follow it. Use the tool map below only for jobs none of them covers. ## Who follows up on an open thread One owner at a time, so nobody is chased twice or forgotten: | Situation | Owner | |---|---| | Agreed to a call, not booked | The booking follow-up (`book-agreed-calls`): from `li_track_booking` until booked or closed. It alone nudges and closes | | Any other open thread where we spoke last and wait on them | A follow-up chain (`li_create_followup_chain`), started after every reply of ours that leaves the thread open | | Never replied | Their campaign sequence (stops on reply) | | "Not now, try in (month)" | `li_snooze_reply`, no chain | | Final verdict, do-not-contact, flagged for the user | Nobody | The server keeps it so: `li_track_booking`, a new `li_mark_booked` and a dated `li_snooze_reply` end the person's chains; `li_create_followup_chain` refuses people the booking follow-up owns; `li_booking_due` skips people a chain owns. The default chain shapes (which the user's outreach skill can override) are in the `answer-replies` skill. Report chains one line each: name, account, step due dates. ## Tool map Every account-scoped tool takes `sessionLabel` (label, LinkedIn name, slug or member id from `li_list_accounts`). "Preview until" a flag means the call is a dry run until that flag is true. Plan and lookups left are in `li_list_accounts` (`plan`, `enrichment`). **Setup** - `li_setup_guide`: the same setup and routine instructions these skills carry, served by the connector, so an assistant without the plugin can follow them too. No `step` = the whole sequence; `account`, `outreach_skill`, `replies`, `invitations`, `bookings`, `posts`, `warm`, `follow_up`, `start_outreach` = one part. Either the skill or this tool is fine. **Accounts and health** - `li_list_accounts`: every account with tier, invite pace, hours, booking settings, plan, research allowance, invite notes this month (`inviteNotes`) and any hold on new invites (`inviteHold`: LinkedIn's weekly limit `WEEKLY_LIMIT`, the invite breaker, or `UNREADABLE`). `invitePace.weeklyCap` is the enforced ceiling; `learnedWeeklyCap`/`learnedAt` (null unless it binds) = lowered after LinkedIn's own weekly-limit refusal, only ever lower, climbing about 10% a week after 2 weeks (our policy). `autoWithdraw.lastRun` is the last cleanup run. Start here. - `li_verify_account`: real sign-in check now; a successful check clears a security-check hold. - `li_login_link`: link for the user to sign in to LinkedIn on PoliteReach's server. Never ask for cookies. - `li_session_status`: saved sessions and their status; `verifyLive` checks one in a browser. - `li_detect_account_tier`: re-read the account's LinkedIn tier. There is no manual tier setting. - `li_rename_account`: rename an account; an empty name follows the LinkedIn name. - `li_pause_account`: hold (`paused: true`) or resume all work. For known outages, not a blocked account. - `li_clear_invite_hold`: lift the invite breaker's hold after someone has checked the account. Never clear it blind. It never lifts LinkedIn's weekly limit; when a hold still stands it returns `stillHeld` + `guidance`. - `li_set_office_hours`: sending hours for invites and scheduled messages, or each prospect's local hours (`sendWindowMode`). `end` is exclusive. - `li_set_auto_withdraw`: daily cleanup of old pending invites. Off by default; a withdrawal blocks re-inviting for about three weeks. - `li_account_activity`: what runs now, what is queued, and why. Read before calling anything stuck. `invites.backlogWarning`: a warning only (new invites still go out) when LinkedIn shows more than 150 pending (300 Premium; our line, not LinkedIn's); if auto-withdraw is off, suggest turning it on (`li_set_auto_withdraw`). `invites.weekSent` is live; a hold reason's numbers are a dated snapshot. - `li_job_result`: what queued work did. A timeout is not a failure; check here, never resend. A `research_…` job id (from `li_research_profiles`) returns that run's rows, 25 a page from `offset`; `fields` (e.g. `[name, role, company, industry, size, location, inPipeline, postUrl]`) returns one flat row per person. **Campaigns and import** - `li_list_strategies` / `li_create_strategy`: sequence templates, at most 4 messages. Create previews until `confirmCreate`. Owned by the user's team (`owner` in the reply). - `li_list_icps` / `li_create_icp`: ICP labels for comparing results. Create previews until `confirmCreate`. - `li_ingest_prospects`: the main import, people plus every prefilled message. Preview until `confirmIngest`; set `launch: false` to stage. ONE call fills many campaigns (up to 500 rows): each row may name its own `sessionLabel`, `campaignName` or `campaignId`, `strategyName` and `icpName`. `defaultSteps` is shared copy for rows without their own (same field names as a row; `{first}` is the only variable). The reply's `campaigns` lists every campaign touched, `routed` each row's outcome, `copy` the rows over a length limit. Pass an `idempotencyKey` and reuse it on a retry. - `li_create_campaign`: manual campaign from targets or CSV. Preview until `confirmCreate`. With no targets it creates an empty campaign. - `li_launch_campaign`: start a staged campaign (`confirmLaunch`). Starts everyone staged in it. Many at once: `campaignIds` (up to 100) or `namePrefix` (+ `sessionLabel`); without `confirmLaunch` it lists what matched. A `namePrefix` launch also needs `expectCount`, the number the preview listed. - `li_pause_campaign`: hold its invites. Already scheduled messages still send. Bulk form as launch, acting only with `confirm: true`. - `li_resume_campaign`: a previously launched campaign restarts its drip by itself. Say so first. Bulk form as pause. - `li_edit_campaign`: rename, change ICP, or `priority: true` so its invites go before the account's other campaigns (only when asked; caps and hours unchanged). Account never changes. Strategy changes once it holds people only with `resnapshot: true`, while nobody in it has been invited or sent anything (`dryRun` previews; `stepTexts` fills text a new step needs). - `li_list_campaigns`: campaigns with ids. `status` is `not_launched` until launch, then `active`, `paused` or `completed`. Filters `status` (e.g. `"not_launched"`), `namePrefix`, `sessionLabel`, `minContacts`/`maxContacts`; page on with `nextOffset`; `fields` and `format: "csv"` shrink the reply. `li_campaign_status`: counts, same `status`. - `li_campaign_contacts`: per person, paged (read `truncated`). Compact by default (`stepCounts`, no copy); `includeSteps: true` for step ids and text. Filters `connectionStatus`, `conversationState`, `hasInbound`; `format: "csv"`. - `li_move_contact`: move people between campaigns on the same account, history kept. `allInCampaign` previews and needs `expectCount`. `resnapshot: true` re-copies untouched movers' steps from the target campaign's strategy. `idempotencyKey` on retries. - `li_reset_contact`: put a contact whose automation died back into the sequence. - `li_check_targets`: who was already approached. Not needed before an import; the import reports `collisions`. `view: "people"` lists every campaign each URL is in (up to 1000 URLs, one compact row each); `campaignNamePrefix` names the campaigns being built so anyone already in them shows in `batch.members`. - `li_experiment_assign`: an A/B test. Splits people across arms (a strategy each, engage on or off) server side, balanced per ICP and account and, when an arm engages, per has-a-post, and stages one campaign per arm, ICP and account. Preview until `confirmAssign`; launch with `li_launch_campaign` on the reply's `launch.campaignIds`. - `li_send_connection_now`: invites only, no messages, queued under the account's pace. Preview until `confirmSend`. **Queued messages** - `li_scheduled_steps`: every message with a send time, soonest first. - `li_accepted_pending_message`: accepted, first message not out yet. `li_due_messages`: steps already due. - `li_edit_step`: rewrite unsent steps by step id. Reversible. - `li_bulk_edit_steps`: replace one exact sentence across a campaign. `dryRun` is true until you set it to false. - `li_cancel_steps`: hold named steps. Cannot be undone; rewrite instead if the message is still wanted. - `li_mark_stopped`: end a person's sequence for good. Not a hold. **Sending** - `li_send_reply`: answer one or many people (`replies`), each from the account the thread is on. Preview until `confirmSend`. A thread it leaves open then gets a follow-up chain. Rows with `bookingCheckRequired` need a calendar search first, then `calendarChecked: true` (booked = send nothing, `li_mark_booked`). A job id means queued; never send twice. - `li_send_message`: one message that waits for the result. Preview until `confirmSend`. - `li_send_bulk_messages`: many messages from one account in one run. Preview until `confirmSend`; batches of 15 or fewer. - All three refuse the identical text to the same person within 10 minutes: the refusal says when it went or was queued, so check the thread or `li_job_result`, never resend. `force: true` skips only that check, and only when the user explicitly wants the same text twice. **Inbox and conversations** - `li_replies_to_answer`: campaign people who replied; `includeThread: true` attaches the thread and a `suggestedOutcome` (a not_interested suggestion from a clear opt-out, never written: read the message first). Each row carries `activeChain` (`chainId`, `accountId`, `stage`, `label`, `nextStepDueAt`, `nextStepMode`, `stepsLeft`) or null; `endsAtNextPass: true` = they wrote after it started, so it stops by itself within the hour; `activeChainUnreadable` = the read failed, check `li_list_chains`. - `li_list_conversations`: live browser read of the inbox, one account per call; `onlyNeedsReply` and `onlyAddressable` give the owed list. `reachedEnd` false = partial. Rows carry `activeChain` or null; `activeChainLookupFailed` = the read failed, check `li_list_chains`. - `li_conversation_history`: stored thread, instant. Empty means never read, not never wrote. - `li_read_conversation`: read one thread live. Slow; only when nothing is stored. - `li_read_conversations_bulk`: live read of many named people in one session; about six at a time. - `li_sweep_inbox`: check for replies now. Not visible in `li_job_result`. - `li_contact_dossier`: everything stored about up to 50 people, including bought research. Open before drafting. - `li_mark_outcome`: the verdict (`won`, `meeting_booked`, `interested`, `not_interested`, `no_outcome`). A demo or a booked call is never `won`. - `li_mark_reply_handled`: the user did their part; says nothing about how it went. - `li_mark_replied`: flag a reply you spotted; stops the sequence. - `li_snooze_reply`: park a thread until a date (`until`). With a date it also ends the person's follow-up chains (`chainsCanceled`); start none. Nothing is sent when it ends. - `li_mark_reviewed`: record a thread as looked at (skip, vendor pitch) without a verdict. - `li_marked_conversations`: people with one verdict; `dueOnly` for snoozes that came due. `outcome: "undecided"` = the verdict queue: replied at least `repliedOlderThanHours` ago (default 48) with no verdict. `owedReply` rows: answer in `li_replies_to_answer` first. **Connections and invitations** - `li_poll_acceptances`: check acceptances now and schedule each first message. - `li_check_acceptance`: one person's connected or pending state. - `li_new_connections`: connections not yet in PoliteReach. - `li_pending_invites`: sent invites still pending. Read `reach`; `partial` or `failed` is not empty. - `li_withdraw_invites`: withdraw pending invites (`confirmWithdraw`). Blocks re-inviting for about three weeks. `li_withdraw_status`: last run. `notFound` = the whole pending list was read and they are not on it; `notReached`/`notReachedCount` = the walk stopped first (`limitedBy`), still pending: never call them gone or re-invite. - `li_received_invitations`: invitations sent to the user. Returns a job id; read it with `li_job_result`. - `li_accept_invitations`: accept named people (`confirmAccept`). No undo. Connection invites only. - `li_mark_invitations`: record rejected, wrong lane or deferred in PoliteReach only (`confirmMark`). Never declines on LinkedIn. - `li_invitation_decisions`: read past triage decisions. `li_unmark_invitation`: forget one (`confirm`). - `li_import_invitation_decisions`: one-time import of an old triage ledger. Preview until `confirmImport`. **Bookings** (you read the calendar; PoliteReach stores state and enforces limits) - `li_track_booking`: they agreed to a call (`agreed: true`, `agreedDayText`, `agreedDate`). Search the calendar first: already booked = `li_mark_booked` instead. Ends every active follow-up chain on the person, on any account of the team, in the same write (`chainsCanceled`, `chainNote`): the booking follow-up owns them now, so `li_cancel_chain` first is not needed. - `li_match_contacts`: calendar attendees to prospects. Mark only `match`, never `ambiguous`. Skip `ignored`. - `li_ignore_calendar_event`: the user says a booking is not from LinkedIn (`eventId`, or `email` for all of theirs; `remove` undoes). `li_match_contacts` then answers `ignored`. - `li_mark_booked`: a call is on the calendar (`calendarEventId`, `meetingStart`); same event, new time is a move. A new booking ends the person's follow-up chains. - `li_mark_booking_cancelled`: the event is gone or cancelled. - `li_bookings`: booked calls to compare with the calendar. - `li_booking_due`: who is due a nudge or a close. Never contact anyone in `excluded`; never lists someone a follow-up chain owns (counted in `excluded.activeChain`). `firstName`/`lastName` already come case-fixed. - `li_set_booking_settings`: booking links (`bookingUrls`), the follow-up pace (`nudgeScheduleDays`, default [2, 5, 10]: days after each message of ours, the last one the close; 1-4 numbers, 1-30, never shrinking), `cancelRecheckHours`, name prefill. The old `maxNudges`, `closeAfterDays` and `firstNudgeHours` are refused. - Nudges and closes go out only through `li_send_reply` with `bookingNudge` or `bookingClose`. **Warm follow-up** (you write every word; PoliteReach holds the plan, the timing and the stop rules) - `li_create_followup_chain`: the next 1-4 touches for ONE person from ONE account (`steps`: `delayDays` 1-60 after our latest message on any channel, strictly growing, never due under 2 hours after creation; `channel` `linkedin` or `email`; `text`; `mode` `send` (LinkedIn, sent in sending hours) or `draft` (waits in `li_warm_due`)). Email is always a draft. Preview until `confirmChain`; `idempotencyKey` on retries. One active chain per person per account; `replaceExisting` cancels the old one (only when our new reply changes the context). Refuses anyone who agreed to a call, and anyone booked unless `stage` is `no_show`, `call_done`, `proposal_sent`, `invited_not_activated` or `trial`; someone only sent the link is allowed. Stops by itself when they write on any channel, agree to a call, book one, get a final verdict (`won`, `not_interested`, `no_outcome`), are snoozed or suppressed. - `li_list_chains`: chains by person or account; `status` `active` (default), `completed`, `canceled` or `all`. - `li_cancel_chain`: stop one (`chainId`, or `profileUrl` + `sessionLabel`) with a short `reason`. - `li_set_stage`: where the deal stands, for `profileUrls`: `agreed`, `booked`, `no_show`, `call_done` (with `note`, `nextStep`, `owner`, `dueDate`), `proposal_sent`, `invited_not_activated`, `trial`, `paid`, `closed`, or null to clear. Not a verdict. - `li_set_contact_email`: save a person's email address. - `li_log_touch`: an email, WhatsApp, call or other touch (`direction` `in` or `out`, `at`, `note`). An inbound one stops their chains, campaign follow-ups and booking nudges. - `li_warm_due`: the warm leads whose next touch is due, most overdue first, each with `reasons` (`chain_step_due`, `next_step_date`, `they_wrote_last`, `quiet`), the due step's text, last touch per channel, and `unreadStreak` (no read receipt on our last messages: never call it unread). Read `truncated`; unreadable is not empty. **Posts** - `li_schedule_post`: post at an exact time the user chose. Cancellable until it goes out. `accountHold` in the reply = that account cannot post now; relay its link. - `li_create_post`: publish now. Preview until `confirmPost`. - `li_scheduled_posts`: queued and recent posts; failed ones carry the reason. - `li_cancel_scheduled_post`: cancel one not yet published. A published post stays. **Reporting** - `li_daily_digest`: one account's day; a blocked account leads. - `li_outcome_summary`: the human verdicts plus booking rates. `undecided` means not judged yet; it splits into `repliedNoVerdict` (work owed), `neverReplied` and `notMessagedYet`. - `li_outreach_analytics`: acceptance and reply rates by strategy, ICP, campaign or account. `repliedEverRate` = how many people replied (does not fall when replies are handled); `replyRate` = replies awaiting a verdict. Filter which campaigns count with `status`, `namePrefix`, `minContacts`/`maxContacts` (same rules as `li_list_campaigns`); paged 50 groups (pass `nextOffset` as `offset`); `fields` for only the columns you need; `format: "csv"` for big comparisons. `groupBy: "arm"` with `experimentId`: per-arm acceptance, reply, booking and `positiveReply` rates with sample sizes and 95% intervals, plus acceptance split by reacted / notReacted (`acceptanceByEngagement`). - `li_connections`: invite list plus acceptance rate. Give `sessionLabel`, or the stats blend accounts. **Do-not-contact** - `li_suppress_profiles`: add people. Preview until `confirmSuppress`. Refused at import, invite and every send. - `li_list_suppressed`: read the list. `li_unsuppress_profile`: remove one. **Research** (uses lookups from the allowance; anyone looked up in the last 30 days is free) - A status of `provider_limit` (or `providerLimit: true` on the reply) on any research tool = our data provider is at its monthly usage limit: not known, retry later, not charged. Never read it as `no_posts` or `not_found`. - `li_research_profiles`: up to 500 people in one call, one merged row each: `pipeline` (every campaign they are in), `profile`, `company`, and `posts` when asked. Someone already in the pipeline reuses a stored profile of any age for free. Long lists return a `jobId` for `li_job_result`. `estimateOnly` first. Prefer it to calling the three tools below and joining by URL. For a big list pass `fields: [name, role, company, industry, size, location, inPipeline, postUrl]` to triage, then read full rows (no `fields`) only for the people you will write to. `postUrl` is a rule pick (newest reactable non-repost post), not a choice. - `li_enrich_profiles`: who people are plus their current employer. `estimateOnly` shows the cost first. Each row has `publicProfileUrl` (import this), `memberId` and `searchId`; `profileUrl` is the address as asked. - `li_enrich_company`: raw web pages about a company for you to read. One lookup per company per 30 days. - `li_search_leads`: find people who fit an ICP from LinkedIn's search filters. 25 lookups per page that returns anyone (a page of 3 costs the same as 25); `estimateOnly` first. All target companies (up to 50), titles and places go in ONE call, never one call per company. Results name people by search id (`/in/ACwAA…`); `publicProfileUrl` is set when already known. Pass the search id to any tool as it is: every tool that takes a profile URL resolves it to the public profile URL first (reported as `searchIds`; previews look it up but never open the browser). - `li_resolve_profile_url`: any spelling of a person (vanity, `ACoAA…` member id, `ACwAA…` search id) → public profile URL, member id and search id. Cache free, then 1 lookup, then the account's browser. Read-only; rarely needed, since every tool resolves search ids itself. - `li_fetch_posts`: a person's latest posts (up to 2, reposts excluded). 1 lookup per person not read in the last 3 days. `no_posts` is not `unreadable`. Only a post with `reactable: true` can be an `engagePostUrl`. **Engagement** - `li_react_to_post`: react (Like by default) to one post from a named account. Preview until `confirmReact`. Shares the account's daily reaction cap with campaigns. A timeout returns a job id: never react again. - In a campaign, `engagePostUrl` on `li_ingest_prospects` reacts to that post first; the invite then follows about a day later, in the person's own morning window (or the account's sending hours; 18-30 hours with no window to aim at). Operator only, not for normal use: `li_trial_watch` (trials and paid grace ending soon, accounts stuck on a sign-in or security check, users who never launched a campaign, invited users who never connected LinkedIn, recent cancellations and why; read-only), `li_host_health`, `li_selector_canary`, `li_proxies`, `li_check_proxy`, `li_set_account_proxy`, `li_set_user_default_proxy`, `li_set_team_billing`, `li_set_default_pricing_tier`, `li_set_team_complimentary`, `li_set_account_complimentary`, `li_set_team_discount` (a discount on a not-yet-subscribed team's first months, emailed to them; refused for a team that already pays), `li_set_trial_end_offer` (the automatic last offer after a trial), `li_hold_sending` (pauses every LinkedIn write on every account, at most 24 hours). ## Ground rules, everywhere - **Preview, then confirm.** Show the dry run, get the user's yes, then call again with the confirm flag. A scheduled task acts only in the mode the user chose when setting it up. - **Prefilled text only.** Every note, message and post is written now and approved. PoliteReach never writes text at send time; the only addition is the recipient's name in the booking link. - **Write names with normal capitals.** A name in all capitals ("SOHAN SINGH") or all lowercase becomes "Sohan" ("MARY-ANNE O'BRIEN" → "Mary-Anne O'Brien"). A mixed-case name ("McDonald", "deVries", "AJ DeVito") is the person's own spelling: keep it exactly. `{first}` in `defaultSteps` applies this for you. - **Invite pace is fixed.** It is PoliteReach's own safety policy per account tier (`invitePace` in `li_list_accounts`), not a LinkedIn rule. No tool or setting raises it. Quote the account's own numbers, never one flat cap. - **No cookies or passwords in chat.** If the user pastes one, tell them to delete it and change it. Sign-in happens from `li_login_link`. - **A security check or sign-in error means stop.** Tell the user to reconnect the account. Never retry around it. - **Never guess the account.** With more than one, every write names it. Two matches is a refusal, not a pick. - **Relay refusals.** A refusal says why (plan, do-not-contact, limits, paused account). Relay it with any link it carries; never work around it. - **Your own accounts only.** At most 4 messages per sequence. A free account drops connection notes.