Skip to content

Business operating system for Claude Code — 57 skills, 21 agents, smart daemon. Unified inbox (WhatsApp/Email/Slack/Telegram), autonomous PR merge, full-AWS monitoring, revenue (Stripe+RevenueCat), e-commerce (Shopify), marketing (Klaviyo/Meta/GA4), voice (Bland/ElevenLabs), APM (Datadog/NewRelic/OTEL), YOLO mode.

refactor(skills): replace wacli CLI calls with mcp__whatsapp__* tools

auroracapital1e62f1ebeefd
diff --git a/claude-ops/agents/comms-scanner.md b/claude-ops/agents/comms-scanner.md
index 30aba01d..5f9a0a27 100644
--- a/claude-ops/agents/comms-scanner.md
+++ b/claude-ops/agents/comms-scanner.md
@@ -25,9 +25,10 @@ Run all channel scans in parallel:
```bash
# WhatsApp — ALL non-archived chats (not just unread)
-wacli chats list --json 2>/dev/null || echo '{"error": "wacli not available"}'
+# WhatsApp via bridge MCP tools
+mcp__whatsapp__list_chats sort_by=last_active # or via sqlite3 direct query
# Then for each chat with recent activity (last 7 days):
-# wacli messages list --chat "<JID>" --limit 5 --json
+# mcp__whatsapp__list_messages chat_jid="<JID>" limit=5
# Check FromMe on last message to classify NEEDS_REPLY vs WAITING
```
diff --git a/claude-ops/agents/daemon-agent.md b/claude-ops/agents/daemon-agent.md
index 7f27be7f..d00a82a1 100644
--- a/claude-ops/agents/daemon-agent.md
+++ b/claude-ops/agents/daemon-agent.md
@@ -60,11 +60,11 @@ tail -f ~/.claude/plugins/data/ops-ops-marketplace/logs/<service-name>.log
## Action Needed
-When a service requires user intervention (e.g. wacli reauth), `action_needed` is set:
+When a service requires user intervention (e.g. whatsapp-bridge restart), `action_needed` is set:
```json
{
- "action_needed": {"service": "wacli-sync", "action": "reauth"}
+ "action_needed": {"service": "whatsapp-bridge", "action": "restart"}
}
```
@@ -78,7 +78,7 @@ Any ops skill that reads `daemon-health.json` should surface this to the user im
"pid": 12345,
"uptime_seconds": 3600,
"services": {
- "wacli-sync": {"status": "running", "pid": 67890, "last_health": "connected", "restarts": 0},
+ "whatsapp-bridge": {"status": "running", "pid": 67890, "last_health": "connected", "restarts": 0},
"memory-extractor": {"status": "scheduled", "next_run": "2026-04-13T15:30:00Z", "last_run": "2026-04-13T15:00:00Z"}
},
"action_needed": null
diff --git a/claude-ops/agents/memory-extractor.md b/claude-ops/agents/memory-extractor.md
index 1c6f6820..79bffd20 100644
--- a/claude-ops/agents/memory-extractor.md
+++ b/claude-ops/agents/memory-extractor.md
@@ -10,7 +10,7 @@ memory: project
## Purpose
Builds structured memory from raw chat data so ops skills (inbox, comms, go) can draft
-context-aware messages. Reads WhatsApp (wacli) and email (gog) history, calls Claude Haiku
+context-aware messages. Reads WhatsApp (bridge messages.db) and email (gog) history, calls Claude Haiku
for extraction, and writes/merges structured markdown memory files.
## Memory Location
@@ -56,8 +56,12 @@ CONTACT_FILE=$(ls "${MEMORIES}/contact_"*deeksha* 2>/dev/null | head -1)
## Data Sources
-- **WhatsApp**: `wacli messages list --after=<yesterday> --limit=200 --json`
- - Requires wacli connected (`~/.wacli/.health` contains "connected")
+- **WhatsApp**: direct sqlite3 query on bridge messages.db:
+ ```bash
+ DB="${WHATSAPP_BRIDGE_DB:-$HOME/.local/share/whatsapp-mcp/whatsapp-bridge/store/messages.db}"
+ sqlite3 "$DB" "SELECT chat_jid, sender, content, timestamp, is_from_me FROM messages WHERE timestamp >= '<yesterday>' ORDER BY timestamp DESC LIMIT 200;"
+ ```
+ - Requires bridge running: `lsof -i :8080 | grep LISTEN`
- **Email**: `gog gmail search -j --results-only --no-input --max 20 "newer_than:1d"`
- Requires gog available
diff --git a/claude-ops/hooks/hooks.json b/claude-ops/hooks/hooks.json
index 28914805..71daf689 100644
--- a/claude-ops/hooks/hooks.json
+++ b/claude-ops/hooks/hooks.json
@@ -24,7 +24,7 @@
"hooks": [
{
"type": "command",
- "command": "bash ${CLAUDE_PLUGIN_ROOT}/bin/ops-pretool-wacli-health \"$TOOL_INPUT\" 2>/dev/null || true"
+ "command": "bash ${CLAUDE_PLUGIN_ROOT}/bin/ops-pretool-whatsapp-bridge-health \"$TOOL_INPUT\" 2>/dev/null || true"
}
]
},
diff --git a/claude-ops/skills/ops-comms/SKILL.md b/claude-ops/skills/ops-comms/SKILL.md
index 9df62899..0f81a327 100644
--- a/claude-ops/skills/ops-comms/SKILL.md
+++ b/claude-ops/skills/ops-comms/SKILL.md
@@ -1,6 +1,6 @@
---
name: ops-comms
-description: Send and read messages across all channels. Routes based on arguments — whatsapp, email, slack, telegram, discord, notion, or natural language like "send [msg] to [contact]".
+description: Send and read messages across all channels. Routes based on arguments — whatsapp, email, slack, telegram, discord, notion, or natural language like "send [msg] to [contact]". WhatsApp via mcp__whatsapp__* (Baileys bridge).
argument-hint: "[channel] | send [message] to [contact] | read [channel] | notion [search query]"
allowed-tools:
- Bash
@@ -36,8 +36,8 @@ maxTurns: 40
Before executing, load available context:
1. **Daemon health**: Read `${CLAUDE_PLUGIN_DATA_DIR:-$HOME/.claude/plugins/data/ops-ops-marketplace}/daemon-health.json`
- - Check `wacli-sync` status before any WhatsApp operation
- - Also check `~/.wacli/.health` — if not `status=connected`, surface auth issue before proceeding
+ - Check bridge liveness before any WhatsApp operation: `lsof -i :8080 | grep LISTEN`
+ - If bridge not running, prompt user to restart: `launchctl kickstart -k gui/$UID/com.<user>.whatsapp-bridge`
2. **Ops memories**: Before drafting any message, check `${CLAUDE_PLUGIN_DATA_DIR}/memories/`:
- `contact_*.md` — load profile for the recipient
@@ -48,20 +48,23 @@ Before executing, load available context:
## CLI/API Reference
-### wacli (WhatsApp)
+### whatsapp-bridge (WhatsApp — mcp__whatsapp__*)
-**Health file** — check `~/.wacli/.health` BEFORE any wacli command:
-- `status=connected` → proceed
-- `status=needs_auth` or `status=needs_reauth` → prompt user for QR scan, do NOT run wacli commands
+**Bridge health** — check bridge is running before any WhatsApp operation:
+```bash
+lsof -i :8080 | grep LISTEN
+launchctl list com.<user>.whatsapp-bridge
+```
+If not running: `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`
-| Command | Usage | Output |
-|---------|-------|--------|
-| `wacli doctor --json` | Check auth/connected/lock/FTS | `{data: {authenticated, connected, lock_held, fts_enabled}}` |
-| `wacli chats list --json` | All chats | `{data: [{JID, Name, Kind, LastMessageTS}]}` |
-| `wacli messages list --chat "<JID>" --limit N --json` | Messages for chat | `{data: {messages: [{FromMe, Text, Timestamp, SenderName, ChatName}]}}` |
-| `wacli messages search --query "<text>" --json` | FTS search | Same as above |
-| `wacli contacts --search "<name>" --json` | Contact lookup | Contact objects |
-| `wacli send --to "<JID>" --message "<msg>"` | Send text | Success/error |
+| Tool | Params | Output |
+|------|--------|--------|
+| `mcp__whatsapp__list_chats` | `{sort_by: "last_active"}` | Array of chats with jid, name, last_message_time |
+| `mcp__whatsapp__list_messages` | `{chat_jid, limit, query}` | Array of messages with is_from_me, content, timestamp, sender |
+| `mcp__whatsapp__search_contacts` | `{query}` | Contacts matching name or phone |
+| `mcp__whatsapp__send_message` | `{recipient, message}` | Send result |
+| `mcp__whatsapp__get_chat` | `{chat_jid}` | Chat metadata |
+| `mcp__whatsapp__get_message_context` | `{chat_jid, message_id}` | Message context window |
### gog CLI (Gmail/Calendar)
@@ -100,7 +103,7 @@ Natural-language parsing: phrases like `send "deploy done" to #general on discor
1. Parse contact name and message from `$ARGUMENTS`.
2. Determine channel by contact lookup:
- - Check WhatsApp: `wacli contacts --search "[contact]" --json 2>/dev/null`
+ - Check WhatsApp: `mcp__whatsapp__search_contacts {query: "[contact]"}` 2>/dev/null
- Check Slack: `mcp__claude_ai_Slack__slack_search_users` with `query: "[contact]"`
- Check email: known from context or ask
3. If multiple channels found, use `AskUserQuestion`: `[WhatsApp]` / `[Slack]` / `[Email]`
@@ -121,17 +124,17 @@ If user picks "Edit message", use `AskUserQuestion` with free-text to get the re
### WhatsApp send
**CRITICAL — READ BEFORE SENDING:** Before drafting ANY WhatsApp reply, you MUST:
-1. Read the full conversation: `wacli messages list --chat "<JID>" --limit 20 --json`
-2. Understand which messages are from the user (`FromMe: true`) vs the contact
+1. Read the full conversation: `mcp__whatsapp__list_messages {chat_jid: "<JID>", limit: 20}`
+2. Understand which messages have `is_from_me: true` (user sent) vs `is_from_me: false` (contact sent)
3. Summarize what the conversation is about and what the contact is asking
4. Only THEN draft a reply that addresses what the contact actually said
**Never send a reply based on a single message.** A message like "can you pull it from Klaviyo?" means nothing without knowing what "it" refers to from prior messages.
-**Pre-flight:** Before any wacli command, check `~/.wacli/.health`. If `status=needs_auth` or `status=needs_reauth`, prompt the user: "WhatsApp needs re-authentication. Run `wacli auth` in a separate terminal and scan the QR code, then type 'done'." Use `AskUserQuestion`: `[Done — re-paired]`, `[Skip WhatsApp]`. On Done, restart daemon: `launchctl kickstart -k gui/$(id -u)/com.claude-ops.wacli-keepalive`, wait 5s.
+**Pre-flight:** Check bridge is running: `lsof -i :8080 | grep LISTEN`. If not running, restart: `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge` and wait 5s.
-```bash
-wacli send --to "[contact]" --message "[message]"
+```
+mcp__whatsapp__send_message {recipient: "[contact_jid]", message: "[message]"}
```
### Slack send
@@ -155,11 +158,11 @@ Draft created for [recipient]:
**WhatsApp:**
-```bash
-wacli chats --limit 10 --json 2>/dev/null
+```
+mcp__whatsapp__list_chats {sort_by: "last_active"}
```
-Show last 10 chats with sender, preview, timestamp.
+Show last 10 chats with sender, preview, timestamp. Use `mcp__whatsapp__list_messages {chat_jid, limit: 5}` to preview each chat.
**Email:**
Use `mcp__claude_ai_Gmail__search_threads` with `query: "in:inbox"` (NOT `is:unread` — scan full inbox including read messages), show thread list.
diff --git a/claude-ops/skills/ops-daemon/SKILL.md b/claude-ops/skills/ops-daemon/SKILL.md
index df841cd1..40c8f7a1 100644
--- a/claude-ops/skills/ops-daemon/SKILL.md
+++ b/claude-ops/skills/ops-daemon/SKILL.md
@@ -162,8 +162,8 @@ Run each check and track results as `pass` / `fail` / `warn`:
10. **Every service has a command** — iterate `daemon-services.json` services; each enabled entry must have a non-empty `command` field. Missing `command` silently skips the service (historical bug).
11. **Running services alive** — for each service in the health file with `status=running|polling`, verify `kill -0 <pid>` succeeds.
12. **Cron services have future `next_run`** — `scheduled` services must have a `next_run` timestamp in the future.
-13. **wacli-sync path resolves** — if enabled, `~/.wacli/.health` exists and is fresh. (Optional — mark warn not fail if missing.)
-14. **No zombie children** — no orphaned `ops-message-listener.sh` or `wacli-keepalive.sh` processes without a parent `ops-daemon.sh`.
+13. **whatsapp-bridge running** — if enabled, `lsof -i :8080 | grep LISTEN` returns a result. (Optional — mark warn not fail if missing.)
+14. **No zombie children** — no orphaned `ops-message-listener.sh` processes without a parent `ops-daemon.sh`.
### Fix playbook
diff --git a/claude-ops/skills/ops-dash/SKILL.md b/claude-ops/skills/ops-dash/SKILL.md
index 95e2ab94..ddfb163c 100644
--- a/claude-ops/skills/ops-dash/SKILL.md
+++ b/claude-ops/skills/ops-dash/SKILL.md
@@ -313,7 +313,7 @@ When user selects `h`:
| 5 | Command reference | List all `/ops:*` commands with descriptions |
| 6 | Shortcuts | `1-9, 0` for actions, `a-h` for power/comms/settings, `b` always goes back, `q` exits |
| 7 | MCP disconnected | Wait 5s and retry (auto-reconnect hook). After 3 fails, falls back to CLI tools. |
-| 8 | WhatsApp | First check `~/.wacli/.health` — if `status` is not `connected`, surface the auth warning before running `wacli doctor`. Check `wacli doctor`. If 405 error: rebuild from source. If store locked: `kill $(pgrep wacli)`. |
+| 8 | WhatsApp | Check bridge liveness: `lsof -i :8080 | grep LISTEN`. If not running, prompt restart: `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`. Check `launchctl list com.<user>.whatsapp-bridge` for status. If store locked: `kill $(pgrep whatsapp-bridge)`. |
| 9 | Telegram | Needs user-auth (not bot). Run `/ops:setup` → Telegram section. API ID + hash from my.telegram.org. |
| 10 | Unread | Channel must be configured in `/ops:setup`. Check `ops-unread` script output for errors. |
diff --git a/claude-ops/skills/ops-go/SKILL.md b/claude-ops/skills/ops-go/SKILL.md
index 80420524..73c75508 100644
--- a/claude-ops/skills/ops-go/SKILL.md
+++ b/claude-ops/skills/ops-go/SKILL.md
@@ -35,23 +35,23 @@ Before executing, load available context:
2. **Daemon health**: Read `${CLAUDE_PLUGIN_DATA_DIR}/daemon-health.json`
- If `action_needed` is not null → surface it before the briefing
- - Check `wacli-sync` status before including WhatsApp unread counts
- - Also check `~/.wacli/.health` for live auth status
+ - Check `whatsapp-bridge` status before including WhatsApp unread counts
+ - Also check bridge liveness: `lsof -i :8080 | grep LISTEN`
-3. **WhatsApp pre-check**: Only include WhatsApp data if `~/.wacli/.health` shows `status=connected`.
+3. **WhatsApp pre-check**: Only include WhatsApp data if bridge is running (`lsof -i :8080 | grep LISTEN`).
## CLI/API Reference
-### wacli (WhatsApp)
+### whatsapp-bridge (WhatsApp — mcp__whatsapp__*)
-**Health file** — check `~/.wacli/.health` BEFORE any wacli command:
-- `status=connected` → proceed
-- `status=needs_auth` or `status=needs_reauth` → prompt user for QR scan
+**Bridge health** — check before any WhatsApp operation:
+- Running: `lsof -i :8080 | grep LISTEN` → proceed
+- Not running → `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`, wait 5s
-| Command | Usage | Output |
-|---------|-------|--------|
-| `wacli doctor --json` | Check auth/connected/lock/FTS | `{data: {authenticated, connected, lock_held, fts_enabled}}` |
-| `wacli chats list --json` | All chats | `{data: [{JID, Name, Kind, LastMessageTS}]}` |
+| Tool | Params | Output |
+|------|--------|--------|
+| `mcp__whatsapp__list_chats` | `{sort_by: "last_active"}` | Array of chats with jid, name, last_message_time |
+| `mcp__whatsapp__list_messages` | `{chat_jid, limit, query}` | Message array with is_from_me, content, timestamp |
### gog CLI (Gmail/Calendar)
diff --git a/claude-ops/skills/ops-inbox/CHANNELS.md b/claude-ops/skills/ops-inbox/CHANNELS.md
index 268875b5..b5988af1 100644
--- a/claude-ops/skills/ops-inbox/CHANNELS.md
+++ b/claude-ops/skills/ops-inbox/CHANNELS.md
@@ -2,55 +2,49 @@
This document explains how to configure each communication channel for the `/ops:ops-inbox` skill. All credentials come from environment variables or CLI auth — **no secrets are committed to this repo**.
-## WhatsApp (wacli)
+## WhatsApp (Baileys bridge)
-**Status:** CLI-based (wacli), no MCP needed.
+**Status:** MCP-based via `mcp__whatsapp__*` tools. No CLI needed.
-**Setup:**
+The Baileys `whatsapp-bridge` binary runs as a persistent LaunchAgent (`com.<user>.whatsapp-bridge`)
+and exposes WhatsApp over a local HTTP/MCP interface on port 8080.
-```bash
-# Install latest version from source (brew version may be outdated)
-git clone https://github.com/steipete/wacli.git /tmp/wacli-src
-cd /tmp/wacli-src
-go build -o wacli ./cmd/wacli/
-cp wacli /usr/local/bin/
+### Setup
-# Authenticate (scans QR code with phone)
-wacli auth
+1. Ensure the bridge binary is installed at `~/.local/share/whatsapp-mcp/whatsapp-bridge/whatsapp-bridge`
+2. Install the LaunchAgent plist from `assets/launchagents/com.<user>.whatsapp-bridge.plist`:
+ ```bash
+ PLIST="$HOME/Library/LaunchAgents/com.<user>.whatsapp-bridge.plist"
+ BRIDGE_DIR="$HOME/.local/share/whatsapp-mcp/whatsapp-bridge"
+ sed -e "s|__BRIDGE_BINARY_PATH__|$BRIDGE_DIR/whatsapp-bridge|g" \
+ -e "s|__BRIDGE_WORKING_DIR__|$BRIDGE_DIR|g" \
+ -e "s|__HOME__|$HOME|g" \
+ "${CLAUDE_PLUGIN_ROOT}/assets/launchagents/com.<user>.whatsapp-bridge.plist" > "$PLIST"
+ launchctl bootstrap gui/$(id -u) "$PLIST"
+ ```
+3. On first run the bridge prints a QR code to its log — scan from WhatsApp → Linked Devices.
+4. Run schema migration: `${CLAUDE_PLUGIN_ROOT}/scripts/whatsapp-bridge-migrate.sh`
-# Verify
-wacli doctor
-# Expected: AUTHENTICATED true, CONNECTED false (until sync runs)
+### Check health
-# Initial sync (takes a minute for 142+ conversations)
-wacli sync
+```bash
+lsof -i :8080 | grep LISTEN # bridge running?
+launchctl list com.<user>.whatsapp-bridge # launchd status
+cat ~/.local/share/whatsapp-mcp/whatsapp-bridge/logs/bridge.err.log | tail -20
```
-**Troubleshooting:**
-
-- `Client outdated (405)`: Rebuild from source above
-- `store is locked`: Kill stale process: `kill $(pgrep wacli)`
-- After version upgrade: `wacli auth logout && wacli auth`
-
-**History limitations:**
-wacli only captures messages **received while connected**. It cannot reliably backfill historical messages after the fact:
+### Troubleshooting
-- `wacli history backfill --chat <jid>` requires ≥1 existing local message per chat and often times out on the WhatsApp on-demand sync response.
-- Chats in the new `@lid` (Linked Device) format frequently return empty message queries because their history was never captured during an active sync session.
-- For ongoing inbox management, run `wacli sync --follow` in a persistent terminal (outside Claude Code) so new messages land in the local DB in real-time.
+- `bridge not running`: `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`
+- Auth expired: check `bridge.err.log` for QR prompt; session stored in `whatsapp.db`
+- Missing messages: restart bridge (re-syncs history on connect)
+- FTS search slow: run `scripts/whatsapp-bridge-migrate.sh` to add FTS5 index
-**Env vars (optional):**
-
-- `WACLI_STORE` — default `~/.wacli`
+### Persistence note
-**Run sync persistently (recommended):**
-
-```bash
-# In a dedicated terminal tab — keeps wacli connected so new messages are captured
-wacli sync --follow
-```
-
----
+The bridge syncs messages continuously while running. History is stored in
+`~/.local/share/whatsapp-mcp/whatsapp-bridge/store/messages.db`.
+The `WHATSAPP_BRIDGE_DB` env var overrides the DB path.
## Email (gog)
diff --git a/claude-ops/skills/ops-inbox/SKILL.md b/claude-ops/skills/ops-inbox/SKILL.md
index af569d30..5a97659c 100644
--- a/claude-ops/skills/ops-inbox/SKILL.md
+++ b/claude-ops/skills/ops-inbox/SKILL.md
@@ -1,6 +1,6 @@
---
name: ops-inbox
-description: Full inbox management across all channels — WhatsApp (wacli), Email (Gmail MCP), Slack (MCP), Telegram (user-auth MCP), Discord (webhook + REST read), Notion (MCP — comments, mentions, assigned tasks). Scans FULL inbox (not just unread), identifies messages needing replies, archives handled conversations.
+description: Full inbox management across all channels — WhatsApp (Baileys bridge via mcp__whatsapp__*), Email (Gmail MCP), Slack (MCP), Telegram (user-auth MCP), Discord (webhook + REST read), Notion (MCP — comments, mentions, assigned tasks). Scans FULL inbox (not just unread), identifies messages needing replies, archives handled conversations.
argument-hint: "[channel: whatsapp|email|slack|telegram|discord|notion|all]"
allowed-tools:
- Bash
@@ -30,6 +30,12 @@ allowed-tools:
- mcp__claude_ai_Notion__notion-create-comment
- mcp__claude_ai_Notion__notion-update-page
- mcp__claude_ai_Notion__notion-create-pages
+ - mcp__whatsapp__list_chats
+ - mcp__whatsapp__list_messages
+ - mcp__whatsapp__search_contacts
+ - mcp__whatsapp__send_message
+ - mcp__whatsapp__get_chat
+ - mcp__whatsapp__get_message_context
effort: high
maxTurns: 60
---
@@ -45,8 +51,8 @@ Before executing, load available context:
- `secrets_manager` / `doppler` — how to resolve channel credentials if not in env
2. **Daemon health**: Read `${CLAUDE_PLUGIN_DATA_DIR}/daemon-health.json`
- - Check `wacli-sync` status — if not running or auth needed, skip WhatsApp and surface the issue
- - Also check `~/.wacli/.health` for live auth status before any wacli command
+ - Check `whatsapp-bridge` status — verify `com.<user>.whatsapp-bridge` is running (`lsof -i :8080` or `launchctl list com.<user>.whatsapp-bridge`)
+ - If bridge is not running, surface the issue before WhatsApp operations
3. **Ops memories**: Check `${CLAUDE_PLUGIN_DATA_DIR}/memories/` before drafting any reply:
- `contact_*.md` — load profile for the contact you're about to reply to
@@ -56,23 +62,42 @@ Before executing, load available context:
## CLI/API Reference
-### wacli (WhatsApp)
+### whatsapp-bridge (WhatsApp — mcp__whatsapp__*)
-**Health file** — check `~/.wacli/.health` BEFORE any wacli command:
-- `status=connected` → proceed normally
-- `status=needs_auth` → prompt user: "Run `wacli auth` in terminal, scan QR"
-- `status=needs_reauth` → prompt user: "WhatsApp session expired. Run `wacli auth` to re-pair"
-- File missing → fall back to `wacli doctor --json`
+**Bridge health** — check bridge is running before any WhatsApp operation:
+```bash
+lsof -i :8080 | grep LISTEN # bridge listens on :8080
+launchctl list com.<user>.whatsapp-bridge # check launchd status
+```
+If bridge is not running: `launchctl kickstart -k gui/$UID/com.<user>.whatsapp-bridge`
-| Command | Usage | Output |
-|---------|-------|--------|
-| `wacli doctor --json` | Check auth/connected/lock/FTS | `{data: {authenticated, connected, lock_held, fts_enabled}}` |
-| `wacli chats list --json` | All chats | `{data: [{JID, Name, Kind, LastMessageTS}]}` |
-| `wacli messages list --chat "<JID>" --limit N --json` | Messages for chat | `{data: {messages: [{FromMe, Text, Timestamp, SenderName, ChatName}]}}` |
-| `wacli messages search --query "<text>" --json` | FTS search | Same as above |
-| `wacli contacts --search "<name>" --json` | Contact lookup | Contact objects |
-| `wacli send --to "<JID>" --message "<msg>"` | Send text | Success/error |
-| `wacli history backfill --chat="<JID>" --count=50 --requests=2 --wait=30s --idle-exit=5s --json` | Fetch older messages | Backfill result |
+**MCP tools** (use these instead of any wacli CLI command):
+
+| Tool | Usage | Output |
+|------|-------|--------|
+| `mcp__whatsapp__list_chats` | `{sort_by: "last_active"}` | Array of chats with jid, name, last_message_time |
+| `mcp__whatsapp__list_messages` | `{chat_jid, limit, query}` | Array of messages with id, sender, content, timestamp, is_from_me |
+| `mcp__whatsapp__search_contacts` | `{query}` | Contacts matching name or phone |
+| `mcp__whatsapp__send_message` | `{recipient, message}` | Send result |
+| `mcp__whatsapp__get_chat` | `{chat_jid}` | Chat metadata |
+| `mcp__whatsapp__get_message_context` | `{chat_jid, message_id}` | Message context window |
+
+**Full-text search** — use `mcp__whatsapp__list_messages` with a `query` param (backed by FTS5 after running `scripts/whatsapp-bridge-migrate.sh`):
+```bash
+# Direct sqlite3 FTS query (fallback when MCP unavailable):
+DB="${WHATSAPP_BRIDGE_DB:-$HOME/.local/share/whatsapp-mcp/whatsapp-bridge/store/messages.db}"
+sqlite3 "$DB" "SELECT chat_jid, sender, content, timestamp FROM messages WHERE rowid IN (SELECT rowid FROM messages_fts WHERE messages_fts MATCH '<query>') ORDER BY timestamp DESC LIMIT 20;"
+```
+
+**Contact lookup** — use `mcp__whatsapp__search_contacts` or query contacts table directly:
+```bash
+sqlite3 "$DB" "SELECT jid, name, phone FROM contacts WHERE name LIKE '%<name>%' COLLATE NOCASE LIMIT 10;"
+```
+
+**History backfill** — the Baileys bridge automatically syncs history on connection. No manual backfill command exists; if messages are missing, restart the bridge:
+```bash
+launchctl kickstart -k gui/$UID/com.<user>.whatsapp-bridge
+```
### gog CLI (Gmail/Calendar)
@@ -128,7 +153,7 @@ All channel credentials come from env vars or CLI auth — no hardcoded secrets.
| `SLACK_MCP_ENABLED` | `false` | Set `true` when Slack MCP server is configured |
| `TELEGRAM_ENABLED` | `false` | Set `true` when Telegram user-auth MCP is configured |
| `NOTION_MCP_ENABLED`| `false` | Set `true` when Notion MCP integration is configured |
-| `WACLI_STORE` | `~/.wacli` | wacli store directory |
+| `WHATSAPP_BRIDGE_DB`| `~/.local/share/whatsapp-mcp/whatsapp-bridge/store/messages.db` | Bridge messages DB path |
## Core principle: FULL INBOX SCAN
@@ -151,16 +176,16 @@ The user does NOT remember every thread. For EVERY message you present, you MUST
**For every NEEDS REPLY item, gather this context automatically:**
-1. **Full thread body** — read the ENTIRE thread (`gog gmail thread get` / `wacli messages list --limit 20`), not just the last message. Summarize the full conversation arc.
+1. **Full thread body** — read the ENTIRE thread (`gog gmail thread get` / `mcp__whatsapp__list_messages {limit: 20}`), not just the last message. Summarize the full conversation arc.
2. **Contact profile** — search across channels to build a card:
- `gog gmail search "from:<contact_email>" --max 10` — recent email history
- - `wacli contacts --search "<name>" --json` — WhatsApp presence
- - `wacli messages search --query "<name>" --json --limit 5` — recent WhatsApp mentions
+ - `mcp__whatsapp__search_contacts {query: "<name>"}` — WhatsApp presence
+ - `mcp__whatsapp__list_messages {query: "<name>", limit: 5}` — recent WhatsApp mentions
- If Linear configured: search for issues assigned to or mentioning this contact
- Present: who they are, role/company, last N interactions, relationship context
3. **Topic context** — identify the subject matter and search for related threads:
- `gog gmail search "subject:<keywords>" --max 5` — related email threads
- - `wacli messages search --query "<topic keywords>" --json --limit 5` — related WA messages
+ - `mcp__whatsapp__list_messages {query: "<topic keywords>", limit: 5}` — related WA messages
- Summarize: what this topic is about, any deadlines, any pending decisions
4. **ops-memories** (if available) — check `~/.claude/plugins/data/ops-ops-marketplace/memories/` for any stored context about this contact or topic
@@ -195,7 +220,7 @@ The user does NOT remember every thread. For EVERY message you present, you MUST
For each channel, detect availability at runtime:
1. **Email**: Try `gog` CLI first. If `gog` unavailable, try `mcp__gog__gmail_*` MCP tools. If neither, report unavailable.
-2. **WhatsApp**: First check `~/.wacli/.health` for keepalive daemon status. If `status=needs_auth` or `status=needs_reauth`, do NOT attempt wacli commands — instead prompt the user: "WhatsApp needs re-authentication. Run `wacli auth` in a separate terminal and scan the QR code, then type 'done'." Use `AskUserQuestion`: `[Done — re-paired]`, `[Skip WhatsApp]`. On Done, restart the daemon: `launchctl kickstart -k gui/$(id -u)/com.claude-ops.wacli-keepalive`, wait 5s, re-check health. If no health file exists, fall back to `wacli doctor` for auth/connection status. If outdated (405 error), advise rebuilding from source.
+2. **WhatsApp**: Check bridge liveness: `lsof -i :8080 | grep LISTEN`. If not listening, prompt the user: "WhatsApp bridge is not running." Use `AskUserQuestion`: `[Restart bridge]`, `[Skip WhatsApp]`. On restart: `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`, wait 5s, re-check. If bridge is running but MCP tools fail, the bridge may need QR re-pairing — check `~/.local/share/whatsapp-mcp/whatsapp-bridge/logs/bridge.err.log` for auth errors.
3. **Slack**: Only via MCP tools (`mcp__claude_ai_Slack__*`). Check `SLACK_MCP_ENABLED` env var.
4. **Telegram**: Only via user-auth MCP (tdlib/MTProto). Check `TELEGRAM_ENABLED` env var. Never use BotFather bots.
5. **Discord**: Via `${CLAUDE_PLUGIN_ROOT}/bin/ops-discord read <CHANNEL_ID> --limit 20 --json`. Requires `DISCORD_BOT_TOKEN` (v1 is channel-scoped — no DM/gateway support yet). Pre-configured read list lives at `${CLAUDE_PLUGIN_DATA_DIR}/preferences.json` under `discord.inbox_channels` (array of channel IDs). If neither a bot token nor a read list is configured, skip Discord with a one-line note ("Discord not configured — run `/ops:setup discord`") rather than prompting — ops-inbox is not a setup flow. Rule 3 still applies to `/ops:setup`.
@@ -207,7 +232,7 @@ For each channel, detect availability at runtime:
2. **For each channel, run a FULL scan** (not just unread):
- **Email**: Search `in:inbox` (not `is:unread`) via `gog gmail search -a $GMAIL_ACCOUNT -j --results-only --no-input --max 30 "in:inbox"`. For each thread, read the last message to determine who sent it last. Check for DRAFT or SENT labels. **Before suggesting to send a draft, verify no reply was already sent in the thread.**
- - **WhatsApp**: Run `wacli chats list --json` to get all chats. Filter to non-archived chats with `LastMessageTS` in the last 7 days. For each, fetch the FULL conversation via `wacli messages list --chat <JID> --limit 20 --json` (20 messages, not 5 — you need the full thread). Parse `data.messages[]` with fields `FromMe`, `Text`, `Timestamp`, `ChatName`. Understand which messages are from the user (`FromMe: true`) vs the contact (`FromMe: false`). Classify by last message `FromMe` field.
+ - **WhatsApp**: Call `mcp__whatsapp__list_chats {sort_by: "last_active"}` to get all chats. Filter to chats with `last_message_time` in the last 7 days. For each, fetch the FULL conversation via `mcp__whatsapp__list_messages {chat_jid, limit: 20}` (20 messages, not 5 — you need the full thread). Parse message array with fields `is_from_me`, `content`, `timestamp`, `sender`. Classify by last message `is_from_me` field.
- **Slack**: Search via Slack MCP tools. Check who sent last message in each thread.
- **Telegram**: Use user-auth MCP (NOT bot API) to read recent conversations.
@@ -252,31 +277,31 @@ If only 3 channels are configured, "All channels" + 3 channel options = 4, fits
### WhatsApp (FULL SCAN + DEEP CONTEXT)
**Phase 1 — Classify:**
-1. Get all chats: `wacli chats list --json`
-2. Filter to chats with `LastMessageTS` in the last 7 days
-3. For each, fetch the FULL recent conversation: `wacli messages list --chat "<JID>" --limit 20 --json` — get 20 messages, NOT 5. You need the full conversation thread to understand context.
-4. Parse `data.messages[]` — fields: `FromMe`, `Text`, `Timestamp`, `ChatName`, `SenderName`
+1. Get all chats: `mcp__whatsapp__list_chats` with `{sort_by: "last_active"}`
+2. Filter to chats with `last_message_time` in the last 7 days
+3. For each, fetch the FULL recent conversation: `mcp__whatsapp__list_messages` with `{chat_jid: "<JID>", limit: 20}` — get 20 messages, NOT 5.
+4. Parse message array — fields: `is_from_me`, `content`, `timestamp`, `sender`
5. For EVERY chat, understand the conversation:
- - Read ALL messages in order. Know which are `FromMe: true` (user sent) vs `FromMe: false` (contact sent)
+ - Read ALL messages in order. Know which have `is_from_me: true` (user sent) vs `is_from_me: false` (contact sent)
- Understand what the conversation is about, what was discussed, what's pending
- Identify the user's tone and style in their sent messages
6. Classify each chat:
- - **NEEDS REPLY**: Last message has `FromMe: false` (they sent last)
- - **WAITING**: Last message has `FromMe: true` (you sent last)
+ - **NEEDS REPLY**: Last message has `is_from_me: false` (they sent last)
+ - **WAITING**: Last message has `is_from_me: true` (you sent last)
- **ARCHIVE**: Old conversation, no recent activity, or concluded
**Phase 2 — Build context for NEEDS REPLY chats (run in parallel):**
For each NEEDS REPLY chat:
1. **Full conversation summary** — read all 20 messages, summarize the arc: what was discussed, key decisions, open questions
2. **Contact profile** — search for this person:
- - `wacli messages search --query "<contact_name>" --json --limit 10` — mentions in other chats
+ - `mcp__whatsapp__list_messages` with `{query: "<contact_name>", limit: 10}` — mentions across chats
- `gog gmail search -j --results-only --no-input --max 5 "from:<name> OR to:<name>"` — email history
- Check `~/.claude/plugins/data/ops-ops-marketplace/memories/contact_*.md` for stored profile
- Build: who they are, relationship, communication history across channels
3. **Topic context** — extract keywords from the conversation and search:
- - `wacli messages search --query "<topic keywords>" --json --limit 5` — related WA messages
+ - `mcp__whatsapp__list_messages` with `{query: "<topic keywords>", limit: 5}` — related WA messages
- `gog gmail search -j --results-only --no-input --max 3 "<topic keywords>"` — related emails
-4. **User's messaging style** — from the `FromMe: true` messages in this chat, note: language (NL/EN), formality, emoji usage, typical response length
+4. **User's messaging style** — from the `is_from_me: true` messages in this chat, note: language (NL/EN), formality, emoji usage, typical response length
**Phase 3 — Present with full context:**
@@ -313,45 +338,28 @@ Use `AskUserQuestion` for each NEEDS REPLY chat.
- If ops-memories has preferences for this contact, apply them
- Never generate a generic reply — every draft must show you understood the full conversation
-Reply via: `wacli send --to "<JID>" --message "<msg>"`
-
-**wacli CLI reference (v0.5.0):**
-
-| Command | Usage | Notes |
-|---------|-------|-------|
-| `wacli doctor` | `wacli doctor --json` | Check auth/connected/lock/FTS status |
-| `wacli auth` | `wacli auth` | QR pairing (interactive — shows QR in terminal) |
-| `wacli sync` | `wacli sync --follow --refresh-contacts --refresh-groups` | Persistent sync (managed by launchd keepalive) |
-| `wacli sync --once` | `wacli sync --once --idle-exit=10s` | One-shot sync, exits when idle |
-| `wacli chats list` | `wacli chats list --json` | All chats with JID, Name, Kind, LastMessageTS |
-| `wacli messages list` | `wacli messages list --chat "<JID>" --limit 5 --json` | Messages: ChatJID, FromMe, Text, Timestamp, SenderName |
-| `wacli messages search` | `wacli messages search --query "<text>" --json` | FTS5 search across all messages |
-| `wacli contacts` | `wacli contacts --search "<name>" --json` | Contact lookup by name |
-| `wacli send` | `wacli send --to "<JID>" --message "<msg>"` | Send text message |
-| `wacli history backfill` | `wacli history backfill --chat="<JID>" --count=50 --requests=2 --wait=30s --idle-exit=5s --json` | Fetch older messages from phone (needs store lock) |
-
-**Health file contract (`~/.wacli/.health`):**
-
-Before ANY wacli command, read `~/.wacli/.health`:
-- `status=connected` → proceed normally
-- `status=needs_auth` → prompt user: "Run `wacli auth` in terminal, scan QR"
-- `status=needs_reauth` → prompt user: "WhatsApp session expired. Run `wacli auth` to re-pair"
-- File missing → fall back to `wacli doctor --json`
+Reply via: `mcp__whatsapp__send_message` with `{recipient: "<JID>", message: "<msg>"}`
-**Requesting backfill for @lid chats with empty messages:**
+**WhatsApp bridge reference:**
-The keepalive daemon holds the store lock, so you can't run backfill directly. Instead:
-1. Write JIDs to `~/.wacli/.backfill_jids` (one per line)
-2. Restart the daemon: `launchctl kickstart -k gui/$(id -u)/com.claude-ops.wacli-keepalive`
-3. The daemon runs backfill before starting persistent sync
+| Operation | Tool / Command |
+|-----------|---------------|
+| List chats | `mcp__whatsapp__list_chats {sort_by: "last_active"}` |
+| Read messages | `mcp__whatsapp__list_messages {chat_jid, limit: 20}` |
+| Search messages (FTS) | `mcp__whatsapp__list_messages {query: "<text>", limit: 20}` |
+| Find contact | `mcp__whatsapp__search_contacts {query: "<name>"}` |
+| Send message | `mcp__whatsapp__send_message {recipient, message}` |
+| Chat metadata | `mcp__whatsapp__get_chat {chat_jid}` |
+| Message context | `mcp__whatsapp__get_message_context {chat_jid, message_id}` |
+| Check bridge | `lsof -i :8080 | grep LISTEN` |
+| Restart bridge | `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge` |
-**wacli troubleshooting:**
+**Bridge troubleshooting:**
-- `@lid` JIDs (linked device format) may return empty messages → request backfill via the daemon (see above)
-- "Client outdated (405)" → rebuild from source: `cd /tmp && git clone https://github.com/Lifecycle-Innovations-Limited/wacli.git && cd wacli && go build -o /usr/local/bin/wacli ./cmd/wacli/`
-- "store is locked" → the keepalive daemon holds the lock; to release: `launchctl bootout gui/$(id -u)/com.claude-ops.wacli-keepalive`
-- Auth expired → daemon writes `needs_auth` to health file; prompt user for QR scan
-- Key desync (0 messages synced) → daemon writes `needs_reauth`; user needs `wacli auth` re-pair
+- Bridge not running → `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`; wait 5s, re-check
+- Auth expired / QR needed → check `~/.local/share/whatsapp-mcp/whatsapp-bridge/logs/bridge.err.log`; bridge prints QR to log on startup if session is invalid
+- Missing messages → bridge syncs history on connect; if gap persists, restart bridge
+- FTS not available → run `scripts/whatsapp-bridge-migrate.sh` to add FTS5 index to messages.db
### Email (FULL SCAN + DEEP CONTEXT)
@@ -370,8 +378,8 @@ For each NEEDS REPLY thread, gather:
1. **Full thread summary** — read every message in the thread, summarize the conversation arc (who said what, key decisions, open questions)
2. **Contact profile** — for the sender:
- `gog gmail search -j --results-only --no-input --max 10 "from:<sender_email>"` — their recent emails to you
- - `wacli contacts --search "<sender_name>" --json` — WhatsApp contact
- - `wacli messages search --query "<sender_name>" --json --limit 5` — recent WhatsApp mentions
+ - `mcp__whatsapp__search_contacts {query: "<sender_name>"}` — WhatsApp contact
+ - `mcp__whatsapp__list_messages {query: "<sender_name>", limit: 5}` — recent WhatsApp mentions
- Build: name, role/company, relationship history, last N interactions
3. **Topic search** — extract key terms from subject + body, then:
- `gog gmail search -j --results-only --no-input --max 5 "subject:<keywords>"` — related threads
@@ -444,7 +452,7 @@ For each result, show channel, sender, preview. Read thread for context.
### Telegram (FULL SCAN — User Account, NOT Bot)
-Telegram integration must authenticate as the user's personal account (user-auth via tdlib/MTProto), NOT a BotFather bot. The goal is to manage real conversations just like WhatsApp via wacli.
+Telegram integration must authenticate as the user's personal account (user-auth via tdlib/MTProto), NOT a BotFather bot. The goal is to manage real conversations just like WhatsApp via the bridge MCP tools.
Use the Telegram user-auth MCP server if available.
diff --git a/claude-ops/skills/ops-status/SKILL.md b/claude-ops/skills/ops-status/SKILL.md
index 618dfc2f..d03ab796 100644
--- a/claude-ops/skills/ops-status/SKILL.md
+++ b/claude-ops/skills/ops-status/SKILL.md
@@ -68,7 +68,7 @@ ${CLAUDE_PLUGIN_ROOT}/bin/ops-status $ARGUMENTS
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
OPS ► STATUS — Mon 14 Apr 2026 09:45 UTC
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- CLIs ✓ gh ✓ aws ✓ jq ✓ node ✗ wacli
+ CLIs ✓ gh ✓ aws ✓ jq ✓ node ✗ whatsapp-bridge
Channels ✓ gog ✓ slack ○ telegram ✗ whatsapp
MCPs ✓ linear ✓ sentry ✓ vercel ○ gmail
Commerce ○ shopify
@@ -83,7 +83,7 @@ ${CLAUDE_PLUGIN_ROOT}/bin/ops-status $ARGUMENTS
```json
{
- "clis": {"gh": "ok", "aws": "ok", "jq": "ok", "node": "ok", "wacli": "missing"},
+ "clis": {"gh": "ok", "aws": "ok", "jq": "ok", "node": "ok", "whatsapp-bridge": "missing"},
"channels": {"whatsapp": "ok", "slack": "ok", "telegram": "not-configured"},
"mcps": {"linear": "ok", "sentry": "ok", "vercel": "ok", "gmail": "not-configured"},
"commerce": {"shopify": "not-configured"},
diff --git a/claude-ops/skills/setup/SKILL.md b/claude-ops/skills/setup/SKILL.md
index ae42a6a2..594d6b9b 100644
--- a/claude-ops/skills/setup/SKILL.md
+++ b/claude-ops/skills/setup/SKILL.md
@@ -48,7 +48,7 @@ Every Bash tool call MUST include a short `description` parameter (5-10 words, e
- Show what's already configured first, so the user only fills gaps.
- **Never show the user's real name or email in output unless the user explicitly provided it in THIS session.** Do not read from memory, existing configs, or environment variables to populate display names.
- **Max 4 options per `AskUserQuestion` call.** The tool schema enforces `<=4` items in the `options` array. When a step lists >4 choices, filter already-configured items first, then batch the rest into multiple sequential calls of <=4 options each, grouped logically. Use `[More options...]` as the last option to bridge between batches.
-- Run ALL diagnostic/probe commands in parallel when possible. Use multiple Bash tool calls in a single message. Never run sequential probes when they're independent (e.g., `gog auth status` AND `wacli doctor` AND keychain scouts should all run simultaneously).
+- Run ALL diagnostic/probe commands in parallel when possible. Use multiple Bash tool calls in a single message. Never run sequential probes when they're independent (e.g., `gog auth status` AND `lsof -i :8080 | grep LISTEN` AND keychain scouts should all run simultaneously).
- All writes go to one of these paths — and nothing else:
- **`$PREFS_PATH`** — per-user preferences + secrets. Resolves to `${CLAUDE_PLUGIN_DATA_DIR:-$HOME/.claude/plugins/data/ops-ops-marketplace}/preferences.json`. Lives in Claude Code's plugin data dir so it survives plugin reinstalls and version bumps. Never committed to git.
- **`${CLAUDE_PLUGIN_ROOT}/scripts/registry.json`** — per-user project registry (gitignored in the source repo). `mkdir -p` its parent if missing.
@@ -142,7 +142,7 @@ ${CLAUDE_PLUGIN_ROOT}/bin/ops-setup-preflight &>/dev/null &
- Telegram: `cat /tmp/ops-preflight/telegram.txt`
- gog/Gmail: `cat /tmp/ops-preflight/gog-gmail.json`
- gog/Calendar: `cat /tmp/ops-preflight/gog-cal.json`
-- WhatsApp: `cat /tmp/ops-preflight/wacli-doctor.json` and `wacli-chats.json`
+- WhatsApp: `cat /tmp/ops-preflight/bridge-health.json`
- MCP servers: `cat /tmp/ops-preflight/mcp-servers.txt`
- GitHub: `cat /tmp/ops-preflight/gh-auth.txt`
- AWS: `cat /tmp/ops-preflight/aws-identity.json`
@@ -180,7 +180,7 @@ Print a compact status header to the user, one line per category:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Shell: zsh → ~/.zshrc
Core CLIs: ✓ jq ✓ git ✓ gh ✓ aws ✓ node
- Channels: ✓ wacli ✓ gog ○ telegram (no token)
+ Channels: ✓ bridge ✓ gog ○ telegram (no token)
Secrets: ✓ doppler (project: my-app, config: dev)
MCPs: ✓ linear ✓ sentry ○ slack ○ vercel
Registry: 19 projects
@@ -274,7 +274,7 @@ Present each batch as a separate `AskUserQuestion` call. Skip batches where all
If multiple CLIs are missing, offer a bulk install first:
```
-Missing CLIs detected: jq, gh, wacli. What would you like to do?
+Missing CLIs detected: jq, gh. What would you like to do?
[Install all missing CLIs (Recommended)]
[Pick which to install]
[Skip CLI installation]
@@ -285,7 +285,7 @@ If the user selects "Install all", install every missing tool in sequence withou
```
Install jq? [Yes, install now] [Skip]
Install gh? [Yes, install now] [Skip]
-Install wacli? [Yes, install now] [Skip — manual install required]
+
```
For each `Yes`, run:
@@ -398,7 +398,7 @@ Install later with: /plugin marketplace add obra/superpowers-marketplace
## Step 2c — Background Daemon (early install, pre-warm caches)
-**Why install the daemon this early?** Running the daemon in parallel with the rest of setup lets it start pre-warming the briefing cache (`ops-gather` results for infra/git/PRs/CI), so by the time the user reaches Step 7 and runs `/ops:go`, the briefing is already cached and loads in under 3 seconds instead of 10. Channel-dependent services (wacli-sync, message-listener, inbox-digest, store-health) are added later in Step 5b once their channels are configured.
+**Why install the daemon this early?** Running the daemon in parallel with the rest of setup lets it start pre-warming the briefing cache (`ops-gather` results for infra/git/PRs/CI), so by the time the user reaches Step 7 and runs `/ops:go`, the briefing is already cached and loads in under 3 seconds instead of 10. Channel-dependent services (message-listener, inbox-digest) are added later in Step 5b once their channels are configured.
### Platform support
@@ -438,7 +438,7 @@ Otherwise ask via `AskUserQuestion`:
Install the ops background daemon now?
Starts pre-warming briefing cache while you finish the rest of setup.
Auto-heals on failure. Single launchd agent (com.claude-ops.daemon).
- Channel services (wacli-sync, message-listener) added after channels are set up.
+ Channel services (whatsapp-bridge health, message-listener) added after channels are set up.
[Yes — install now] [Skip — I'll run it manually later]
```
@@ -491,15 +491,15 @@ cat > "$SERVICES_CONFIG" <<JSON
"command": "${CLAUDE_PLUGIN_ROOT}/scripts/ops-memory-extractor.sh",
"cron": "*/30 * * * *",
"health_file": "~/.claude/plugins/data/ops-ops-marketplace/memories/.health",
- "_note": "Idle until channels are configured; will extract profiles once wacli/gog are live."
+ "_note": "Idle until channels are configured; will extract profiles once whatsapp-bridge/gog are live."
}
}
}
JSON
-# Remove the old standalone wacli keepalive if present
-launchctl bootout gui/$(id -u)/com.claude-ops.wacli-keepalive 2>/dev/null || true
-rm -f "$HOME/Library/LaunchAgents/com.claude-ops.wacli-keepalive.plist"
+# Remove legacy whatsapp-bridge keepalive if still present
+launchctl bootout gui/$(id -u)/com.claude-ops.whatsapp-bridge-keepalive 2>/dev/null || true
+rm -f "$HOME/Library/LaunchAgents/com.claude-ops.whatsapp-bridge-keepalive.plist" 2>/dev/null || true
# Load daemon in background — does NOT block the wizard
launchctl bootout gui/$(id -u) "$PLIST_DEST" 2>/dev/null || true
@@ -794,7 +794,7 @@ If the user selects "Pick individually", ask which channels using `AskUserQuesti
| Option | Header | Description |
| -------- | -------- | ----------------------------------------------------------------------- |
| Telegram | telegram | Bot token + owner ID for `/ops-comms telegram` |
-| WhatsApp | whatsapp | wacli doctor + auto-heal + backfill |
+| WhatsApp | whatsapp | bridge health check + QR pair + schema migration |
| Email | email | gog CLI → Gmail MCP fallback for `/ops-inbox email` |
| Slack | slack | Slack MCP server (managed by Claude Code) |
@@ -862,7 +862,7 @@ Whenever a channel has a **browser-based OAuth flow** available, offer that firs
| Sentry | `claude mcp add sentry` | DSN / auth token |
| Vercel | `claude mcp add vercel` | personal access token |
| Telegram | ❌ no OAuth (Bot API is token-only by design) | auto-scan + manual paste (only option) |
-| WhatsApp | QR pairing via `wacli auth` (similar UX to OAuth) | n/a — paired sessions only |
+| WhatsApp | QR pairing via `whatsapp-bridge auth` (similar UX to OAuth) | n/a — paired sessions only |
When a channel supports OAuth, the default `AskUserQuestion` should lead with it:
@@ -1137,220 +1137,98 @@ Sub-flow (only runs if user selected Yes above):
> **Deep-dive:** see `${CLAUDE_PLUGIN_ROOT}/skills/ops-comms/SKILL.md` for full operational instructions, CLI reference, and troubleshooting for this integration. The setup agent can load that file directly when it needs more depth than this wizard provides.
-### 3b — WhatsApp (doctor + self-heal + backfill)
+### 3b — WhatsApp (bridge health + QR pair)
-WhatsApp is the channel that most often breaks silently. The wizard must **auto-diagnose, doctor, and fix** — not just report status and give up. Run this whole sub-flow top-to-bottom, stopping only when the system is healthy or the user declines a remediation.
+WhatsApp is handled exclusively by the Baileys `whatsapp-bridge` (managed by `com.<user>.whatsapp-bridge` LaunchAgent) and accessed via `mcp__whatsapp__*` tools.
#### Step 3b.1 — Presence
-Run `command -v wacli`. If missing, ask `AskUserQuestion`: `[Show install docs]`, `[Skip WhatsApp]`. On install docs, print:
-
-```
-wacli is not on Homebrew. Install:
- git clone https://github.com/Lifecycle-Innovations-Limited/wacli ~/src/wacli
- cd ~/src/wacli && go build -o /usr/local/bin/wacli ./cmd/wacli
-```
-
-and stop this sub-flow.
-
-#### Step 3b.2 — Collect state
-
-Run these in parallel:
+Check bridge binary exists and LaunchAgent is installed:
```bash
-wacli doctor --json 2>&1
-wacli auth status --json 2>&1
-wacli messages list --after="$(date -v-1d +%Y-%m-%d 2>/dev/null || date -d '1 day ago' +%Y-%m-%d)" --limit=5 --json 2>&1
-wacli chats list --json 2>&1 | head -c 4000
+ls ~/.local/share/whatsapp-mcp/whatsapp-bridge/whatsapp-bridge 2>/dev/null && echo "binary ok"
+launchctl list com.<user>.whatsapp-bridge 2>/dev/null | head -3
+lsof -i :8080 2>/dev/null | grep LISTEN
```
-Parse:
-
-- `doctor.data.authenticated` (bool)
-- `doctor.data.lock_held` + `doctor.data.lock_info` (PID + acquired_at timestamp)
-- `doctor.data.fts_enabled` (bool — if false, search is degraded, not fatal)
-- `messages.data.messages` length → **this is the key health signal**. Authed with zero messages in the last 24h = broken.
-- `chats` count and whether it populated at all
-
-#### Step 3b.3 — Diagnose and classify
-
-Apply these rules in order. Stop at the first match.
-
-**A. Not authenticated**
-If `doctor.authenticated: false` → print "WhatsApp needs QR pairing. Run `wacli auth` in a separate terminal and scan the QR code with your phone (WhatsApp → Linked Devices → Link a device), then re-run /ops:setup whatsapp." End of sub-flow. Do **not** try to automate the QR scan — it requires the user's phone camera pointed at the terminal (exception to Rule 2).
-
-**B. Stuck sync (stale lock)**
-If `lock_held: true` AND the `lock_info.acquired_at` is older than 2 minutes AND the lock-holder PID is still alive (`ps -p <pid>`):
-
-1. Run `wacli sync` in the background (`timeout 15 wacli sync 2>&1`) via the existing process's stderr tail — OR if we can't tee into it, fall back to:
-2. Ask `AskUserQuestion`: `"A wacli sync process (pid=N) has been holding the store lock for Xm. Most likely stuck. Kill it?"` → `[Kill pid N and restart sync]`, `[Leave it running]`.
-3. On kill: `kill <pid>` (not -9 first). Wait 3s. If still alive, `kill -9 <pid>`. Verify with `ps -p <pid>`.
-4. After kill, re-run `wacli doctor --json` to confirm lock is released. Continue to the next rule.
-
-**C. App-state key desync (the big one)**
-Run `timeout 15 wacli sync 2>&1 | tee /tmp/wacli-sync-probe.log` (must be done after B so the lock is free). Grep the output for:
-
-- `didn't find app state key` → **session keys are desynced**, needs re-pair
-- `failed to decode app state` → same class of error
-- `Failed to do initial fetch of app state` → same class of error
-
-If any match:
-
-1. Print the diagnosis verbatim:
- ```
- ⚠ WhatsApp session is authenticated but the app-state decryption keys
- are out of sync with your primary device. This happens when the
- linked-device session is partially wiped on the phone side.
- Symptom: sync runs but 0 messages come through.
- Fix: logout this session and re-pair via QR.
- ```
-2. Ask `AskUserQuestion`: `[Logout and walk me through re-pair]`, `[Skip — I'll fix manually]`.
-3. On logout: run `wacli auth logout --json` and show the result. Then print:
- ```
- Now run `wacli auth` in a separate terminal (QR-based auth — requires your phone camera).
- A QR code will appear — scan it from WhatsApp → Settings → Linked Devices → Link a device.
- When it says "Connected", come back and type "done".
- ```
-4. Wait for the user to confirm via `AskUserQuestion`: `[Done — re-paired]`, `[Cancel]`.
-5. On Done, re-run Step 3b.2 to re-collect state and continue to rule D.
-
-**D. Authenticated, lock free, no recent messages, no key errors**
-This is usually a cold cache. Go to Step 3b.4 (backfill).
-
-**E. Healthy (messages flowing)**
-If `messages.data.messages` has ≥1 entry from the last 24h, print a ✓ summary and skip to Step 3b.5.
-
-#### Step 3b.4 — Historical backfill (background, silent)
-
-Always run this after a fresh re-pair, AND run it when rule D matches. Never skip unless the user explicitly declines.
-
-Backfill is a background optimization — it should not produce verbose output or alarming status messages. Run it silently and swallow non-fatal errors.
-
-1. Load the top 10 chats by recency:
- ```bash
- wacli chats list --json 2>&1 | jq -r '[.data[] | select(.jid) | {jid, name, last_msg: .last_message_ts}] | sort_by(.last_msg) | reverse | .[0:10]'
- ```
-2. Tell the user: `"Running historical backfill on your 10 most-recent chats. This runs in the background."` Do not print per-chat progress or 0-message results.
-3. For each chat JID, run **sequentially** (backfill shares the store lock, can't parallelize):
- ```bash
- wacli history backfill --chat="<jid>" --count=50 --requests=2 --wait=30s --idle-exit=5s --json 2>&1
- ```
-4. **Suppress all per-chat output.** If the command exits non-zero, swallow the error silently — backfill failures are not user-visible events. Do NOT print "0 messages synced", error tracebacks, or explanations about device connectivity.
-5. After the loop completes, print only the final health summary (Step 3b.6).
-
-#### Step 3b.5 — FTS index check (optional)
-
-If `doctor.fts_enabled: false`, print:
+If binary missing: ask `AskUserQuestion`: `[Show install docs]`, `[Skip WhatsApp]`. On install docs, print:
```
-ℹ Full-text search is disabled — `wacli messages search` will use SQL LIKE (slower).
- This is a non-fatal known-limitation. See wacli docs to enable FTS5.
+whatsapp-bridge (Baileys) is not installed. Install:
+ git clone https://github.com/your-org/whatsapp-mcp ~/.local/share/whatsapp-mcp
+ cd ~/.local/share/whatsapp-mcp/whatsapp-bridge && go build -o whatsapp-bridge .
+ mkdir -p ~/.local/share/whatsapp-mcp/whatsapp-bridge/logs
```
-Don't block on this.
-
-#### Step 3b.6 — Record state
-
-Write `channels.whatsapp = "wacli"` to `$PREFS_PATH` and print the final ✓ summary:
-
-```
-✓ WhatsApp — wacli authenticated, N chats
+If LaunchAgent not installed, install it from template:
+```bash
+PLIST_TEMPLATE="${CLAUDE_PLUGIN_ROOT}/assets/launchagents/com.<user>.whatsapp-bridge.plist"
+PLIST_DEST="$HOME/Library/LaunchAgents/com.<user>.whatsapp-bridge.plist"
+BRIDGE_DIR="$HOME/.local/share/whatsapp-mcp/whatsapp-bridge"
+mkdir -p "$BRIDGE_DIR/logs"
+sed -e "s|__BRIDGE_BINARY_PATH__|$BRIDGE_DIR/whatsapp-bridge|g" \
+ -e "s|__BRIDGE_WORKING_DIR__|$BRIDGE_DIR|g" \
+ -e "s|__HOME__|$HOME|g" \
+ "$PLIST_TEMPLATE" > "$PLIST_DEST"
+launchctl bootstrap gui/$(id -u) "$PLIST_DEST"
```
-Never include message counts or backfill results in this summary line.
-
-#### Step 3b.7 — Persistent connection (keepalive)
-
-After successful auth and backfill, set up a persistent connection that keeps wacli connected and auto-syncing. This is what makes WhatsApp reliable across sessions — without it, the linked device disconnects after ~14 days of inactivity and @lid JIDs return empty messages.
+#### Step 3b.2 — QR pairing (first run)
-**If the ops-daemon is configured (Step 5b), wacli runs as a daemon service** — skip the standalone launchd path below and note to the user that wacli sync is managed by the daemon. The daemon handles bootstrap, auto-backfill, and health reporting centrally.
-
-**Standalone launchd fallback** (only if the ops-daemon is NOT being set up):
-
-**1. Install the keepalive script:**
+On first run, the bridge needs QR pairing. Check `bridge.err.log`:
```bash
-KEEPALIVE_SCRIPT="${CLAUDE_PLUGIN_ROOT}/scripts/wacli-keepalive.sh"
-chmod +x "$KEEPALIVE_SCRIPT"
+tail -50 ~/.local/share/whatsapp-mcp/whatsapp-bridge/logs/bridge.err.log 2>/dev/null
```
-**2. Generate the launchd plist from template:**
+If log contains a QR code or "scan QR" message, print to the user:
-```bash
-PLIST_TEMPLATE="${CLAUDE_PLUGIN_ROOT}/scripts/com.claude-ops.wacli-keepalive.plist"
-PLIST_DEST="$HOME/Library/LaunchAgents/com.claude-ops.wacli-keepalive.plist"
-LOG_DIR="$HOME/.claude/plugins/data/ops-ops-marketplace/logs"
-mkdir -p "$LOG_DIR" "$HOME/Library/LaunchAgents"
+```
+The bridge is waiting for QR pairing.
+Open ~/.local/share/whatsapp-mcp/whatsapp-bridge/logs/bridge.err.log in a terminal to see the QR code.
+Scan it from WhatsApp → Settings → Linked Devices → Link a device.
+```
-# Resolve bash 4+ (same logic as daemon plist)
-BASH_PATH="/bin/bash"
-if [[ -x /opt/homebrew/bin/bash ]]; then
- BASH_PATH="/opt/homebrew/bin/bash"
-elif [[ -x /usr/local/bin/bash ]]; then
- BASH_PATH="/usr/local/bin/bash"
-fi
+Use `AskUserQuestion`: `[Done — QR scanned]`, `[Skip WhatsApp]`. This is the ONLY step that requires user's phone.
-sed -e "s|__KEEPALIVE_SCRIPT_PATH__|$KEEPALIVE_SCRIPT|g" \
- -e "s|__BASH_PATH__|$BASH_PATH|g" \
- -e "s|__LOG_DIR__|$LOG_DIR|g" \
- -e "s|__HOME__|$HOME|g" \
- "$PLIST_TEMPLATE" > "$PLIST_DEST"
-```
+#### Step 3b.3 — Schema migration
-**3. Load the agent:**
+After bridge is running and paired, run the idempotent schema migration:
```bash
-# Unload if already loaded (idempotent)
-launchctl bootout gui/$(id -u) "$PLIST_DEST" 2>/dev/null || true
-launchctl bootstrap gui/$(id -u) "$PLIST_DEST"
+bash "${CLAUDE_PLUGIN_ROOT}/scripts/whatsapp-bridge-migrate.sh"
```
-**4. Verify it's running:**
+This adds FTS5 index and contacts table to messages.db. Safe to re-run.
+
+#### Step 3b.4 — Smoke test
-Wait 3 seconds, then check:
```bash
-launchctl print gui/$(id -u)/com.claude-ops.wacli-keepalive 2>&1 | head -5
-cat "$HOME/.wacli/.health" 2>/dev/null
+lsof -i :8080 | grep LISTEN # bridge running?
+DB="$HOME/.local/share/whatsapp-mcp/whatsapp-bridge/store/messages.db"
+sqlite3 "$DB" "SELECT COUNT(*) FROM messages;" 2>/dev/null # messages present?
+sqlite3 "$DB" "SELECT COUNT(*) FROM messages_fts;" 2>/dev/null # FTS index present?
```
-If the health file shows `status=connected` or `status=needs_reauth`, the daemon is working. Print:
+If messages > 0 and FTS index present, print:
```
-✓ WhatsApp keepalive — launchd agent installed and running
- Persistent sync active. Auto-restarts on disconnect.
- Health: ~/.wacli/.health | Logs: ~/.claude/plugins/data/ops-ops-marketplace/logs/
+✓ WhatsApp — bridge running, N messages, FTS indexed
```
-If `status=needs_reauth`, immediately trigger the re-pair flow from Step 3b.3 Rule C.
-
-**5. How the keepalive self-heals:**
-
-The keepalive script (`wacli-keepalive.sh`) handles these failure modes automatically:
-
-| Failure | Auto-fix |
-|---------|----------|
-| Orphaned wacli process holding lock | Kills stale PIDs, clears lock |
-| Connection drop (WhatsApp server restart) | launchd restarts within 60s |
-| App-state key desync | Writes `needs_reauth` to health file — ops skills detect this and prompt QR |
-| Auth expired | Writes `needs_auth` — same prompt flow |
-| Script crash | launchd KeepAlive=true restarts immediately (throttled 60s) |
+#### Step 3b.5 — Record state
-**6. Health file contract for other ops skills:**
+Write `channels.whatsapp = "whatsapp-bridge"` to `$PREFS_PATH`.
-All ops skills that use WhatsApp (`ops-inbox`, `ops-comms`, `ops-go`) MUST check `~/.wacli/.health` before attempting wacli commands. If `status=needs_auth` or `status=needs_reauth`:
+**Health contract for other ops skills:**
-1. Print the diagnosis to the user:
- ```
- ⚠ WhatsApp needs re-authentication.
- Run `wacli auth` in a separate terminal and scan the QR code with your phone
- (QR-based auth — exception to Rule 2). Then type "done" to continue.
- ```
-2. Use `AskUserQuestion`: `[Done — re-paired]`, `[Skip WhatsApp]`.
-3. On Done: restart the keepalive daemon via `launchctl kickstart -k gui/$(id -u)/com.claude-ops.wacli-keepalive` and wait 5s for health file update.
+All ops skills that use WhatsApp must check `lsof -i :8080 | grep LISTEN` before MCP tool calls.
+If bridge is not running:
+1. Print: "WhatsApp bridge is not running."
+2. Use `AskUserQuestion`: `[Restart bridge]`, `[Skip WhatsApp]`.
+3. On restart: `launchctl kickstart -k gui/$(id -u)/com.<user>.whatsapp-bridge`, wait 5s.
-This ensures the user is never silently left with a broken WhatsApp connection — every ops skill surfaces the problem and walks them through the fix.
-
-> **Deep-dive:** see `${CLAUDE_PLUGIN_ROOT}/skills/ops-comms/SKILL.md` and `${CLAUDE_PLUGIN_ROOT}/skills/ops-inbox/SKILL.md` for full operational instructions, CLI reference, and troubleshooting for this integration. The setup agent can load those files directly when it needs more depth than this wizard provides.
+> **Deep-dive:** see `${CLAUDE_PLUGIN_ROOT}/skills/ops-comms/SKILL.md` and `${CLAUDE_PLUGIN_ROOT}/skills/ops-inbox/SKILL.md` for full operational instructions.
### 3c — Email
@@ -3120,7 +2998,7 @@ After auto-discovery (or if the user selects "I'll enter projects manually"):
## Step 5b — Daemon Service Reconciliation
-By now, the daemon was already installed in Step 2c and has been pre-warming the briefing cache in the background while the user configured channels. This step adds **channel-dependent services** (`wacli-sync`, `message-listener`, `inbox-digest`, `store-health`, `competitor-intel`) now that we know which channels and integrations are configured.
+By now, the daemon was already installed in Step 2c and has been pre-warming the briefing cache in the background while the user configured channels. This step adds **channel-dependent services** (`whatsapp-bridge-sync`, `message-listener`, `inbox-digest`, `store-health`, `competitor-intel`) now that we know which channels and integrations are configured.
**Skip conditions:**
- If the user declined daemon install in Step 2c, skip this step entirely.
@@ -3148,7 +3026,7 @@ cat "$DATA_DIR/daemon-health.json" 2>/dev/null
Parse the JSON. If `action_needed` is not null, surface the required action to the user. If the daemon wrote a health file, print:
```
-✓ Background daemon — running (wacli-sync: connected, memory-extractor: scheduled)
+✓ Background daemon — running (whatsapp-bridge-sync: connected, memory-extractor: scheduled)
```
If the health file is missing (daemon may still be initializing), wait 5 more seconds and retry once. If still missing, print:
@@ -3163,7 +3041,7 @@ If the health file is missing (daemon may still be initializing), wait 5 more se
Determine which services to enable based on what was configured in earlier steps. The `briefing-pre-warm` and `memory-extractor` services were already enabled at Step 2c — preserve them. Add channel-dependent services based on what's now configured:
-- `wacli-sync` — always include if WhatsApp is configured (`channels.whatsapp` is set)
+- `whatsapp-bridge-sync` — always include if WhatsApp is configured (`channels.whatsapp` is set)
- `memory-extractor` — always include
- `inbox-digest` — always include (runs every 4h, aggregates all configured channels)
- `store-health` — include ONLY if ecommerce was configured (`ecom.shopify.store_url` is set in `$PREFS_PATH`)
@@ -3174,9 +3052,9 @@ Build the services array programmatically (starting from the 2c baseline):
```bash
SERVICES='["briefing-pre-warm","memory-extractor","inbox-digest","competitor-intel"]'
PREFS=$(cat "$PREFS_PATH" 2>/dev/null || echo '{}')
-# Add wacli-sync + message-listener if WhatsApp is configured
+# Add whatsapp-bridge-sync + message-listener if WhatsApp is configured
if echo "$PREFS" | jq -e '.channels.whatsapp' > /dev/null 2>&1; then
- SERVICES=$(echo "$SERVICES" | jq '. + ["wacli-sync","message-listener"]')
+ SERVICES=$(echo "$SERVICES" | jq '. + ["whatsapp-bridge-sync","message-listener"]')
fi
# Add message-listener for Telegram too (deduplicate)
if echo "$PREFS" | jq -e '.channels.telegram' > /dev/null 2>&1; then
@@ -3191,7 +3069,7 @@ echo "Services to enable: $SERVICES"
Write daemon services config to `$DATA_DIR/daemon-services.json` — merge with the existing config from Step 2c, preserving `briefing-pre-warm` and `memory-extractor`, and enabling the new channel-dependent services. **Every service MUST include a `command` field** — the daemon's `start_service()` skips any service without one. Use `${CLAUDE_PLUGIN_ROOT}` (resolved at runtime) for script paths. Each service entry should include:
- `briefing-pre-warm`: `{ "enabled": true, "command": "${CLAUDE_PLUGIN_ROOT}/bin/ops-gather", "cron": "*/2 * * * *" }` — pre-warms /ops:go cache (installed in 2c)
-- `wacli-sync`: `{ "enabled": true, "command": "${CLAUDE_PLUGIN_ROOT}/scripts/wacli-keepalive.sh", "health_file": "~/.wacli/.health", "restart_delay": 60, "max_restarts": 10 }` — only if WhatsApp configured
+- `whatsapp-bridge-sync`: `{ "enabled": true, "command": "${CLAUDE_PLUGIN_ROOT}/scripts/whatsapp-bridge-keepalive.sh", "health_file": "~/.whatsapp-bridge/.health", "restart_delay": 60, "max_restarts": 10 }` — only if WhatsApp configured
- `memory-extractor`: `{ "enabled": true, "command": "${CLAUDE_PLUGIN_ROOT}/scripts/ops-memory-extractor.sh", "health_file": "~/.claude/plugins/data/ops-ops-marketplace/memories/.health", "cron": "*/30 * * * *" }` — every 30 min (installed in 2c)
- `inbox-digest`: `{ "enabled": true, "command": "${CLAUDE_PLUGIN_ROOT}/scripts/ops-cron-inbox-digest.sh", "cron": "0 */4 * * *" }` — every 4h
- `store-health`: `{ "enabled": true, "command": "${CLAUDE_PLUGIN_ROOT}/scripts/ops-cron-store-health.sh", "cron": "0 9 * * *" }` — daily 9am, only if ecom configured
@@ -3217,7 +3095,7 @@ Use `run_in_background: true` on the reload command. Do NOT wait for it — cont
Write `daemon.enabled = true` and `daemon.services` (the reconciled array) to `$PREFS_PATH`. Print:
```
-✓ Daemon services reconciled — N services enabled (briefing-pre-warm, memory-extractor, wacli-sync, ...)
+✓ Daemon services reconciled — N services enabled (briefing-pre-warm, memory-extractor, whatsapp-bridge-sync, ...)
Daemon reloading in background.
```
@@ -3563,7 +3441,7 @@ Re-run the detector and present a final status dashboard:
✓ MCPs: linear, sentry, vercel
✓ Registry: 20 projects
✓ Prefs: saved to ~/.claude/plugins/data/ops-ops-marketplace/preferences.json
- ✓ Daemon: ops-daemon → wacli-sync, memory-extractor, inbox-digest
+ ✓ Daemon: ops-daemon → whatsapp-bridge-sync, memory-extractor, inbox-digest
Next: /ops-go for your first briefing
──────────────────────────────────────────────────────
@@ -3607,7 +3485,7 @@ If `$ARGUMENTS` contains a specific section name, jump straight to that section:
| `cli`, `install` | Step 2 |
| `channels` | Step 3 |
| `telegram` | Step 3a |
-| `whatsapp`, `wacli`, `whatsapp-doctor` | Step 3b |
+| `whatsapp`, `whatsapp-bridge`, `whatsapp-doctor` | Step 3b |
| `email` | Step 3c |
| `slack` | Step 3d |
| `notion` | Step 3e |
@@ -3717,35 +3595,35 @@ gog auth status # Check auth
gog auth add [email protected] --services gmail,calendar,drive,contacts,docs,sheets
```
-### wacli
+### whatsapp-bridge
```bash
# Health check
-wacli doctor --json
+lsof -i :8080 | grep LISTEN --json
# Auth status
-wacli auth status --json
+whatsapp-bridge auth status --json
# List chats (MUST use subcommand `list`)
-wacli chats list --json
+whatsapp-bridge chats list --json
# List messages (--after flag uses YYYY-MM-DD)
# macOS
-wacli messages list --after="$(date -v-1d +%Y-%m-%d)" --limit=5 --json
+whatsapp-bridge messages list --after="$(date -v-1d +%Y-%m-%d)" --limit=5 --json
# Linux
-wacli messages list --after="$(date -d '1 day ago' +%Y-%m-%d)" --limit=5 --json
+whatsapp-bridge messages list --after="$(date -d '1 day ago' +%Y-%m-%d)" --limit=5 --json
# Send message
-wacli send --to "JID" --message "text"
+whatsapp-bridge send --to "JID" --message "text"
# Sync (connect and pull)
-wacli sync
+whatsapp-bridge sync
# Backfill history
-wacli history backfill --chat="JID" --count=50 --requests=2 --wait=30s --idle-exit=5s --json
+whatsapp-bridge history backfill --chat="JID" --count=50 --requests=2 --wait=30s --idle-exit=5s --json
# Contact lookup
-wacli contacts --search "name" --json
+whatsapp-bridge contacts --search "name" --json
```
> After setup, the memory-extractor daemon service will populate `memories/contact_*.md` from this contact data.