wacli-pro

intent

send whatsapp messages through the wacli CLI in a way that feels intentional, human, and context-aware. use this skill when the user wants to message someone from their personal account, reply to existing conversations with proper context, draft messages that sound like them (not an AI), manage follow-ups, or send files. the skill prioritizes natural tone, relationship matching, and explicit confirmation before sending anything.

inputs

• wacli CLI: installed and available on the system path. get it from the wacli project or clawhub ecosystem.
• wacli authentication: user must have run wacli auth at least once. the CLI stores session state locally (phone-based auth via WhatsApp QR code).
• phone online: the device linked to the user's WhatsApp account must be online and connected to the internet for sync and send operations to work.
• chat JID (optional): when searching or backfilling a specific conversation, you need the chat's jabber ID. obtain it via wacli chats list --json and match by name or phone number.
• recipient phone number: in full E.164 format (e.g., "+14155551212"). required for new sends. verify before sending.
• file path (optional): absolute or relative path to the file you want to send. the file must exist and be readable.

procedure

1. confirm the recipient's identity, the message goal, and any constraints the user cares about (tone, length, urgency).

   • input: user request (explicit recipient, message intent, or conversation reference).
   • output: confirmed recipient phone or chat reference, goal statement, and tone preference.

2. if the message is a reply or follow-up to an existing conversation, search or backfill that chat to gather context.

   • input: chat name or phone number from step 1; optional keyword to search for.
   • output: recent message history from wacli (JSON parsed) showing prior commits, prices, dates, or tone patterns.

3. draft the message in the appropriate tone (casual, professional-warm, or firm-concise) based on the relationship and goal.

   • input: context from step 2 (if applicable), user's voice/examples, relationship type, goal statement.
   • output: proposed message text. avoid AI phrases, boilerplate, and over-explanation. use short natural sentences.

4. if the message includes a file, prepare the file path and optional caption.

   • input: file path from user and any desired caption text.
   • output: verified file path (absolute or relative) and caption text (max 1-2 sentences).

5. confirm the final send plan in one compact line (recipient, message text, file and caption if any).

   • input: message text from step 3, recipient from step 1, file details from step 4.
   • output: user approval or request to revise.

6. send the message via wacli using the appropriate command (text or file).

   • input: recipient phone, message text, file path and caption (if applicable).
   • output: wacli command execution result (success or error).

7. report exactly what was sent, including recipient, timestamp (if available from wacli output), and message text or file name.

   • input: wacli send command result.
   • output: confirmation statement to user with full details of what was delivered.

decision points

• if the user says "reply", "follow up", "answer them", or "continue the chat": run context-first workflow (steps 2 and 3) to search or backfill history before drafting. do not assume prior commitments or details.

• if the relationship or prior promise matters: search or backfill the chat. dates, prices, attachments, or commitments may already exist in the thread. ground your draft in actual history, not assumptions.

• if the user asks to "sound natural" or "like me": search recent context to match their actual tone and phrasing style in that conversation. study prior messages to that recipient before drafting.

• if multiple matching chats exist for the phone or name: ask the user which one they mean. do not guess.

• if the message is sensitive, high-impact, or relationship-damaging (e.g., a breakup, a complaint, a refusal, or a big ask): offer a draft first and require explicit approval before sending. do not auto-send.

• if the user provides exact recipient and exact message text and clearly asks "send it now": send without a second stylistic review, but restate what was sent afterward.

• if wacli auth is missing or expired: run wacli auth to re-authenticate. a new QR scan may be needed.

• if wacli is authenticated but not connected (e.g., "not synced" error or messages not delivering): run wacli sync --follow, verify the phone is online, and retry after connection is restored. network timeouts or stale sessions require a reconnect.

• if chat lookup returns no results or weak matches: try searching by phone number instead of name, run wacli history backfill --chat <jid> --requests 2 --count 50 to load more history, or use narrower keywords and date windows.

• if the requested message violates safety (e.g., user's direct OpenClaw chat, guessing a recipient, or sharing sensitive personal data): decline and explain why. do not send.

• if the send command fails (e.g., invalid phone format, file not found, rate limit hit): report the error, suggest a fix (e.g., re-format the number, verify the file exists, wait before retrying), and do not retry automatically without user approval.

• if the file is too large or an unsupported format: wacli will reject it. report the error and ask the user to use a smaller file or different format.

output contract

success means:

• the message was sent to the correct recipient via wacli and confirmed by the CLI output (no error exit code).
• the message text or file (with caption) is exactly what the user approved in step 5.
• the wacli command used was either wacli send text --to <phone> --message "<text>" or wacli send file --to <phone> --file <path> --caption "<caption>".
• the user receives a confirmation statement restating the recipient phone, message text (or file name and caption), and any delivery status from wacli.
• if history was searched, the context-gathering commands used --json flag to ensure machine-readable output.

failure or partial success means:

• the send command exited with a non-zero code (auth error, network error, invalid recipient, file not found, rate limit).
• the user was not shown the context or was not asked for explicit confirmation.
• the message was sent to the wrong recipient, or the wrong text was sent.
• a sensitive or relationship-damaging message was sent without a draft review first.

outcome signal

the skill worked when:

• the user confirms they received a notification on their phone that the message was sent.
• the recipient replies or acknowledges receipt (visible in their WhatsApp thread).
• wacli reports "sent" or "delivered" status and the message appears in the user's chat history.
• the user says "thanks, sent" or provides positive feedback on the tone or context matching.
• the file attachment is visible on the recipient's end (for file sends).

the skill failed when:

• wacli returns an error code (auth expired, network unavailable, invalid phone format, rate limited).
• the user says "that's not what I wanted to send" or "that's the wrong person".
• the message was not delivered (visible as "failed" or "error" in wacli output or WhatsApp).
• the user had to manually revise and resend because the drafted tone or content was wrong.
• a sensitive message was sent without explicit approval, damaging the relationship.

credits: original skill by prantikmedhi (clawhub). enriched for implexa quality standards.