---
name: signaldash-safe-usage
description: Safely search stored LinkedIn connections, inspect exact contact state and action budgets, approve or reject exact Secretary drafts, read, mark read, reply to comments, delete exact own content, and send LinkedIn, WhatsApp, or email messages through the SignalDash MCP without triggering account restrictions or contacting the wrong person. Use whenever an agent uses a SignalDash read, send, invitation, comment-reply, or delete tool.
---

# Use SignalDash safely

Treat LinkedIn, WhatsApp, and email as human accounts, not bulk messaging APIs.

## Before every send

1. Confirm the requested channel and exact chat.
2. Use `li_list_chats`, `wa_list_chats`, or `email_list`; never fetch profiles
   or mailboxes in bulk.
3. Read at least the 10 most recent messages in the exact thread with
   `li_read_messages`, `wa_read_messages`, or `email_read`.
4. Check the recipient, prior conversation, last inbound message, and whether
   the proposed text was already sent.
5. Obtain explicit human approval for the exact recipient and exact text when
   the user has not already approved both.
6. Send one message, then read the thread again to confirm delivery.

The only Secretary notification exception is server-rendered and goes to
Federico's exact verified Secretary WhatsApp group after its database setting
is explicitly enabled. It re-resolves that group live, never uses a self-chat,
sends only for a newly stored exact signal or draft identity, and sends nothing
on a no-change cycle. This exception grants no authority to contact a third
party.

Never infer a recipient from a partial name. Never send blind. Never retry a
send after an ambiguous timeout without first reading the thread.

Reading is non-mutating. Confirmed sends, created chats, and scheduled sends
clear unread by default; pass `mark_read:false` to preserve unread. Explicit
`li_mark_read` and `wa_mark_read` calls are also available.

For a Secretary draft, approve only the exact `disposition_id` and
`payload_hash` returned by `sd_secretary_latest`. Pass the resulting
`secretary_receipt_id` alone to `li_send_message`. Never add or edit a chat,
recipient, text, attachment, watermark, or mark-read field beside the receipt.
On no, call `sd_secretary_reject` for that exact disposition and send nothing.

## Contact-state limits

- `sd_contact_state` uses exact user-and-channel identifiers only. It does not
  infer that a LinkedIn profile, WhatsApp number, and email address belong to
  one person.
- Inspect state with `action:"get"` before outreach planning. Stop when
  `campaign_eligible` is false.
- Add a suppression only after explicit human approval of the exact channel,
  identifier kind, and reason. Use `action:"suppress"` with an allowed reason
  and `confirm:true`.
- Never switch identifiers or channels to evade `contact_suppressed`,
  `recipient_replied`, `already_contacted`, or `already_connected`.
- MCP cannot clear a suppression. Escalate mistaken suppressions to the
  SignalDash operator.

## Email limits

- `email_send` accepts one recipient per call. Never loop to simulate a bulk
  send.
- Approve and verify the exact recipient, subject, and body.
- The server requires a recent `email_read` containing that recipient address,
  blocks exact duplicates, and counts the send against the persisted daily cap.
- If no prior thread exists with the recipient, do not send through SignalDash.
- Stop on authentication errors, HTTP 403, HTTP 429, bounces, or provider
  warnings. Re-read the mailbox and sent history before resolving any ambiguous
  send outcome.

## LinkedIn limits

- Prefer `li_search_connections` for list building inside the user's existing
  network. It searches the account-scoped stored snapshot and exact local
  contact state only; it makes no LinkedIn, Unipile, HarvestAPI, or other paid
  discovery request. A missing snapshot requires the paced `signaldash
  connections` sync, never an improvised profile-fetch loop.
- Treat connection-search results as planning evidence, not action approval.
  Inspect `already_in_contact`, `contact_state`, and `blocking_reasons`.
  Resolve, review, and approve every later action through its one-object flow.
- Read `sd_budget_status` before planning multiple LinkedIn actions. Treat its
  invitation, existing-thread message, and own-post engagement lanes
  separately. Treat the aggregate cap and campaign-excluded portion as brakes,
  never as a promised allowance. Its counts cover SignalDash attempts, not all
  native LinkedIn activity.
- Keep normal messaging at human volume. Code defaults are 20 invitation
  actions, 30 existing-thread messages, 50 own-post engagement actions, and a
  75-attempt aggregate brake per UTC day. The unchanged sent-invitation policy
  also caps attempts at 100 per UTC week.
- Let SignalDash serialize LinkedIn writes and apply action-specific jitter. Do
  not parallelize write calls or bypass the guard. Invitation jitter completes
  before the server's final provider preflight and action reservation.
- The same exact comment reply text is allowed up to ten times per UTC day,
  which covers a human replying briefly and repeatedly. The eleventh is
  refused as `duplicate_comment_text`; changing punctuation only to evade
  that guard is prohibited.
- Campaign invitations use a sender-local Monday-Friday 09:00-17:00 work
  window and a durable 90-180 second per-sender pacing interval. Timing is
  checked before final preflight and atomically during action reservation.
  Downtime does not authorize a catch-up burst.
- `li_create_invitation_batch` accepts only 1-10 immutable canonical LinkedIn
  `/in/` URLs with an exact inclusion reason and optional exact note for each
  target. It starts a durable preview, never a provider write. Use
  `li_get_invitation_batch` until the preview is complete, then give the exact
  `approval_url` to the human.
- MCP cannot approve a batch. Never enter the human credential, automate the
  approval page, preselect targets, or claim approval from an MCP confirmation.
  The human authenticates separately, reviews every stored row, and selects
  each exact invitation.
- To cancel, first call `li_get_invitation_batch`, show the exact state and
  approval hash, obtain explicit approval, then call
  `li_cancel_invitation_batch` once with that exact hash and `confirm:true`.
  Cancel affects only unstarted targets and cannot recall an executing write.
- Do not emulate pause, resume, priority, future scheduling, recurring runs,
  dynamic target generation, or automatic follow-ups. A changed target, note,
  reason, sender binding, or source label requires a new batch and new human
  approval.
- SignalDash does not expose future start dates, recurring schedules,
  automatic follow-ups, acceptance-triggered messages, or multi-message
  sequences. Treat every later message as new context that needs a fresh
  thread read, exact draft, and human approval.
- LinkedIn invitation ceilings vary and often surface around 100 invitations
  per week. SignalDash enforces a separate default policy cap of 100 outbound
  invitation attempts per stable sender each UTC week. This is not a claim
  about a LinkedIn-safe threshold.
- Preview `li_send_invitation` once without `confirm`, show the exact target and
  note, obtain approval, then repeat the identical payload once with
  `confirm:true`.
- Before `li_accept_invitation` or `li_withdraw_invitation`, list the exact
  current received or sent invitation, show the exact action, and obtain
  approval. Never loop over an invitation page.
- Relationship uncertainty, an existing connection, an existing one-to-one
  chat, a pending invitation in either direction, an incomplete bounded page,
  a sender lock, or `outcome_unknown` blocks the action.
- Never bulk-fetch profiles, run enrichment sweeps, or repeatedly open
  individual profiles. Prefer chat lists, exported connection data, and
  cached records.
- Stop all LinkedIn activity on any checkpoint, warning, restriction, unusual
  verification prompt, HTTP 403, or HTTP 429.
- Before `li_reply_to_comment`, read the exact own post comments, preserve the
  exact parent, trigger and watermark, show the full reply text, and obtain
  approval. The server readback, not the provider 2xx alone, proves success.
- Before `li_delete_message` or any future enabled `li_delete_comment`, read
  and show the exact own object and obtain explicit approval. Deletion is
  remediation after exposure, not rollback. It cannot undo a notification or
  a recipient having read the content, and it never weakens any send gate.
- Treat `li_delete_comment` as unavailable while its capability reports
  `untested`. Never change that flag merely to complete a task.

LinkedIn detects behavior, not only API request frequency. Repeated copy,
bursting sends, high profile-view volume, many ignored invitations, concurrent
sessions, and repeated checkpoint retries trigger restrictions.

## WhatsApp limits

- SignalDash hard-caps at 30 send attempts per account per UTC day and
  enforces 15 to 35 seconds between sends.
- Send only in existing, relevant conversations unless the human explicitly
  authorizes a new contact.
- Avoid repeated identical text, bulk cold outreach, rapid group posting, and
  many new chats from a fresh number.
- Use an established number with real conversation history. Keep the primary
  phone powered on and connected so linked-device history remains current.
- Stop on logout, QR re-authentication, delivery anomalies, provider warnings,
  HTTP 403, or HTTP 429.

## When a guard blocks

Do not work around daily caps, jitter, duplicate detection, account scoping,
or the persistent warning lock.

On a warning or `outcome_unknown`:

1. Stop all sends on that account.
2. Inspect LinkedIn or WhatsApp manually for a restriction or checkpoint.
3. Wait until the account is clearly back in good standing.
4. Let the hosted SignalDash operator reconcile and clear the durable sender
   lock. A local session change cannot clear it.
5. Resume at a lower volume.

Let the agent act slowly and human-like. Account health outranks throughput.
