@oxygen-agent/cli 1.209.6 → 1.218.5

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.209.6
+Version: 1.218.5

package/dist/index.js

@@ -1296,6 +1296,35 @@ export function createProgram() {
         .action(async (sessionId, options) => {
         await handleAsyncAction("notetaker status", options, () => requestOxygen(`/api/cli/notetaker/sessions/${encodeURIComponent(sessionId)}`));
     }));
+    program
+        .command("dashboards")
+        .description("Default GTM dashboards: the stitched Command Center funnel across the sequencer, unibox, and CRM.")
+        .addCommand(new Command("summary")
+        .description("Show the GTM funnel summary: touches → replies → positive → meetings → deals → won, with this-period revenue, channel split, and needs-action triage counts.")
+        .option("--range <range>", "Preset range: 7d, 14d, 28d, or 30d. Defaults to 14d.")
+        .option("--from <date>", "Custom start date (YYYY-MM-DD).")
+        .option("--to <date>", "Custom end date (YYYY-MM-DD).")
+        .option("--cold-deal-days <n>", "Days of no activity before an open deal counts as cold. Defaults to 14.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("dashboards summary", options, () => {
+            const params = new URLSearchParams();
+            const range = readOption(options.range);
+            const from = readOption(options.from);
+            const to = readOption(options.to);
+            const coldDealDays = readOption(options.coldDealDays);
+            if (range)
+                params.set("range", range);
+            if (from)
+                params.set("from", from);
+            if (to)
+                params.set("to", to);
+            if (coldDealDays)
+                params.set("cold_deal_days", coldDealDays);
+            const qs = params.toString();
+            return requestOxygen(`/api/cli/dashboards/summary${qs ? `?${qs}` : ""}`);
+        });
+    }));
     program
         .command("crm")
         .description("Agent-native CRM object setup and metadata commands.")
@@ -4460,6 +4489,9 @@ export function createProgram() {
         .option("--min-spacing-seconds <n>", "Minimum seconds between actions.")
         .option("--spacing-jitter-seconds <n>", "Random jitter seconds added to action spacing.")
         .option("--timezone <tz>", "IANA timezone the daily action counters reset in, e.g. America/New_York.")
+        .option("--warmup-restart", "Start (or restart) the warm-up ramp now — gradually raises this account's invite + message caps to full over ~2 weeks.")
+        .option("--warmup-disable", "Turn off warm-up for this account (treat it as already warm and use its full configured caps).")
+        .option("--warmup-start-date <date>", "Set the warm-up start date (ISO, e.g. 2026-01-31). A past date credits prior warming and advances the ramp.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("senders limits set", options, () => {
@@ -4470,11 +4502,229 @@ export function createProgram() {
             });
         });
     }))));
+    program.addCommand(new Command("connections")
+        .description("Read a LinkedIn account's 1st-degree connections (your network) into a Clay-like workspace table you can enrich, qualify, and enroll from. Imports run as a slow, durable background drip under a dedicated conservative read budget — they never burst and never starve the sequencer's own reads.")
+        .addCommand(new Command("import")
+        .description("Start (or re-arm) a connections import. Connections drip into a workspace table over many ticks; poll `connections status` to watch them accrue. The import keeps the table fresh by periodically re-walking the network in the background (new connections dedupe in). No messages are sent and no Oxygen credits are charged.")
+        .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id). Omit to import every active LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to import into. Omit to create or reuse a 'LinkedIn Connections' table.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("connections import", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            return requestOxygen("/api/cli/linkedin/connections/import", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show connections-import progress (per-sender drip status, connections ingested, last error) plus a preview of the connections table and a deep-link to open it.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("connections status", options, () => {
+            const account = readOption(options.account);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/connections/status${suffix ? `?${suffix}` : ""}`);
+        });
+    })));
+    program.addCommand(new Command("engagement")
+        .description("Harvest a LinkedIn post's engagers (reactors + commenters) into an enrollable CRM static list. The harvest runs as a slow, durable background drip under a dedicated conservative read budget — it never bursts and never starves the sequencer's own reads.")
+        .addCommand(new Command("harvest")
+        .description("Start (or re-arm) a harvest of a post's engagers into a CRM static list you can enroll into a sequence. Engagers drip into the list over many ticks; poll `engagement status` to watch it fill. No messages are sent and no Oxygen credits are charged.")
+        .requiredOption("--post <social_id>", "Composite post social_id from `oxygen posts get` (NOT the activity URN).")
+        .requiredOption("--list <slug>", "CRM static list slug to fill (created or reused over the people object).")
+        .option("--recurring", "Keep re-polling the newest pages for new engagers (default: one walk).")
+        .option("--account <ref>", "Sender account that reads (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--no-reactions", "Skip reactors.")
+        .option("--no-comments", "Skip commenters.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("engagement harvest", options, () => {
+            const post = readOption(options.post);
+            const list = readOption(options.list);
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/engagement/harvest", {
+                method: "POST",
+                body: {
+                    ...(post ? { post } : {}),
+                    ...(list ? { list } : {}),
+                    ...(options.recurring ? { recurring: true } : {}),
+                    ...(account ? { account } : {}),
+                    // commander sets reactions/comments=false for --no-* flags.
+                    ...(options.reactions === false ? { include_reactions: false } : {}),
+                    ...(options.comments === false ? { include_comments: false } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show an engagement harvest's progress (drip status, engagers ingested, last error) plus the CRM list it fills and a preview of harvested engagers.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--post <social_id>", "Scope to one harvested post.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("engagement status", options, () => {
+            const account = readOption(options.account);
+            const post = readOption(options.post);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            if (post)
+                params.set("post", post);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/engagement/harvest${suffix ? `?${suffix}` : ""}`);
+        });
+    })));
+    program.addCommand(new Command("linkedin")
+        .description("LinkedIn read-into-workspace ingestion controls (Goal-3): the unified status of the connections / engagement / message-history drips and each account's remaining ingest read budget.")
+        .addCommand(new Command("ingestion")
+        .description("Inspect the LinkedIn ingestion drips that read your network, post engagers, and message history into the workspace.")
+        .addCommand(new Command("status")
+        .description("Unified status of every LinkedIn ingestion drip (connections import, engagement harvest, message-history backfill) plus each account's remaining ingest read budget for the day.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin ingestion status", options, () => {
+            const account = readOption(options.account);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/ingestion/status${suffix ? `?${suffix}` : ""}`);
+        });
+    }))));
+    program.addCommand(new Command("whatsapp")
+        .description("Manage the org's connected WhatsApp accounts for Sequencer: list, connect, sync, inspect, disconnect, tune daily limits, and warm-send into an existing conversation. Cold outbound runs through a WhatsApp sequence (sequences create --channels whatsapp).")
+        .addCommand(new Command("accounts")
+        .description("List connected WhatsApp accounts with health status, warm-up ramp state, limits, and today's usage.")
+        .option("--status <status>", "Filter by account status: active, paused, disconnected, restricted, or credentials_required.")
+        .option("--no-usage", "Skip today's per-account usage counts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("whatsapp accounts", options, () => {
+            const params = new URLSearchParams();
+            if (options.usage !== false)
+                params.set("include_usage", "true");
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/whatsapp/accounts${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("connect")
+        .description("Get a Unipile hosted-auth URL to connect a new WhatsApp account by scanning a QR in WhatsApp → Linked Devices (or reconnect with --reconnect). Newly connected accounts start a mandatory warm-up ramp.")
+        .option("--reconnect <connection_id>", "Reconnect an existing connection id instead of linking a new account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("whatsapp connect", options, () => {
+            const reconnect = readOption(options.reconnect);
+            return requestOxygen("/api/cli/whatsapp/connect", {
+                method: "POST",
+                body: { ...(reconnect ? { reconnect_connection_id: reconnect } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one WhatsApp account with limits, warm-up ramp state (account age + today's effective send floor), daily-reset timezone, and usage. <id> accepts an account id, connection id, or Unipile account id.")
+        .argument("<id>", "WhatsApp account id, connection id, or Unipile account id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("whatsapp get", options, () => requestOxygen(`/api/cli/whatsapp/accounts/${encodeURIComponent(id)}`));
+    }))
+        .addCommand(new Command("sync")
+        .description("Refresh WhatsApp account state (status) from Unipile. Pass --connection-id to sync one account, or omit to sync all.")
+        .option("--connection-id <id>", "Sync a specific connection id. Defaults to syncing all connected accounts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("whatsapp sync", options, () => {
+            const connectionId = readOption(options.connectionId);
+            return requestOxygen("/api/cli/whatsapp/accounts/sync", {
+                method: "POST",
+                body: { ...(connectionId ? { connection_id: connectionId } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("disconnect")
+        .description("Disconnect a WhatsApp account so it stops sending. <id> accepts an account id, connection id, or Unipile account id.")
+        .argument("<id>", "WhatsApp account id, connection id, or Unipile account id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("whatsapp disconnect", options, () => requestOxygen("/api/integrations/whatsapp/disconnect", { method: "POST", body: { id } }));
+    }))
+        .addCommand(new Command("limits")
+        .description("View and adjust per-account WhatsApp daily limits and the daily-reset timezone. The warm-up ramp is a non-bypassable floor on the message cap regardless of these values.")
+        .addCommand(new Command("get")
+        .description("Show current WhatsApp limits, the warm-up ramp state, daily-reset timezone, defaults, and safe maximums. <id> accepts an account id, connection id, or Unipile account id.")
+        .argument("<id>", "WhatsApp account id, connection id, or Unipile account id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("whatsapp limits get", options, () => requestOxygen(`/api/cli/whatsapp/accounts/${encodeURIComponent(id)}/limits`));
+    }))
+        .addCommand(new Command("set")
+        .description("Adjust per-account WhatsApp daily limits and the daily-reset timezone. Values are clamped to safe maximums; the warm-up ramp still floors the message cap. <id> accepts an account id, connection id, or Unipile account id.")
+        .argument("<id>", "WhatsApp account id, connection id, or Unipile account id.")
+        .option("--messages-per-day <n>", "Daily WhatsApp messages cap (subject to the warm-up ramp floor).")
+        .option("--total-actions-per-day <n>", "Daily cap across all WhatsApp action types.")
+        .option("--messages-reads-per-day <n>", "Daily cap on chat and message-history reads.")
+        .option("--min-spacing-seconds <n>", "Minimum seconds between actions.")
+        .option("--spacing-jitter-seconds <n>", "Random jitter seconds added to action spacing.")
+        .option("--timezone <tz>", "IANA timezone the daily action counters reset in, e.g. America/New_York.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("whatsapp limits set", options, () => {
+            const body = buildLinkedinLimitsBody(options);
+            return requestOxygen(`/api/cli/whatsapp/accounts/${encodeURIComponent(id)}/limits`, {
+                method: "PATCH",
+                body,
+            });
+        });
+    })))
+        .addCommand(new Command("warm-send")
+        .description("Send ONE warm WhatsApp message into an EXISTING conversation (warm-only; a cold phone number with no prior conversation is rejected). Approval-gated: omit --approved for a preview, then re-run with --approved to send. For cold outbound at scale, use a WhatsApp sequence instead.")
+        .requiredOption("--account <ref>", "Connected WhatsApp account id, connection id, Unipile account id, or display-name ref that owns the conversation.")
+        .requiredOption("--text <text>", "Message text to send.")
+        .option("--conversation <id>", "Existing WhatsApp conversation id or Unipile chat id to send into.")
+        .option("--approved", "Actually send. Omit for a preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("whatsapp warm-send", options, () => {
+            const account = readOption(options.account);
+            const text = readOption(options.text);
+            if (!account)
+                throw new Error("--account is required.");
+            if (!text)
+                throw new Error("--text is required.");
+            const conversation = readOption(options.conversation);
+            if (!conversation) {
+                throw new Error("--conversation is required — warm-send targets an existing WhatsApp conversation, not a cold phone number.");
+            }
+            return requestOxygen("/api/cli/whatsapp/warm-send", {
+                method: "POST",
+                body: {
+                    account,
+                    text,
+                    conversation_id: conversation,
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    })));
     program.addCommand(new Command("inbox")
-        .description("Unified inbox (unibox): LinkedIn conversations and (--channel email) the fleet's email conversations synced from Zapmail Zapbox. Scan, read threads, and reply.")
+        .description("Unified inbox (unibox): email + LinkedIn + WhatsApp conversations in one stream (--channel all), or a single channel. Scan, read threads, and reply.")
         .addCommand(new Command("list")
-        .description("List conversations across all connected accounts, newest first. --channel email lists the Zapbox-synced email inbox; filter it by status, campaign, mailbox provider/domain, and Primary/Others bucket.")
-        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
+        .description("List conversations newest first. --channel all merges email + LinkedIn + WhatsApp into one stream (narrow it with --channels); --channel email/linkedin/whatsapp lists a single channel. Filter email by status, campaign, mailbox provider/domain, and Primary/Others segment.")
+        .option("--channel <channel>", "Inbox channel: all (merged), linkedin (default), whatsapp, or email.")
+        .option("--channels <list>", "channel=all only: comma-separated channel groups to include (email,linkedin,whatsapp). Empty = all three.")
         .option("--account <id>", "LinkedIn only: filter to one sender account (sender id, connection id, or Unipile account id).")
         .option("--unread", "Only show conversations with unread messages.")
         .option("--responses-only", "Email only: only conversations with an inbound reply (never sent-only threads).")
@@ -4506,6 +4756,7 @@ export function createProgram() {
             for (const [flag, key] of [
                 ["bucket", "bucket"],
                 ["segment", "segment"],
+                ["channels", "channels"],
                 ["status", "status"],
                 ["sequenceId", "sequence_id"],
                 ["provider", "provider"],
@@ -4532,7 +4783,7 @@ export function createProgram() {
         .addCommand(new Command("get")
         .description("Get one conversation with its full message thread. <conversation> accepts a conversation id, Unipile chat id, or (email) Zapbox thread id.")
         .argument("<conversation>", "Conversation id, Unipile chat id, or Zapbox thread id.")
-        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default), whatsapp, or email.")
         .option("--message-limit <n>", "Maximum messages to return (1-500). Defaults to 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
@@ -4549,10 +4800,10 @@ export function createProgram() {
         });
     }))
         .addCommand(new Command("send")
-        .description("Reply into a conversation. --channel email replies from the conversation's own mailbox (Zapbox/native Gmail/Graph, threaded); default replies into the LinkedIn conversation. Sends a real message — requires --approved. Without it, returns a preview.")
+        .description("Reply into a conversation. --channel email replies from the conversation's own mailbox (Zapbox/native Gmail/Graph, threaded); --channel whatsapp warm-replies into an existing WhatsApp conversation; default replies into the LinkedIn conversation. Sends a real message — requires --approved. Without it, returns a preview.")
         .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
         .requiredOption("--text <message>", "Reply text to send.")
-        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default), whatsapp (warm reply), or email.")
         .option("--approved", "Approve and send the message. Without this flag, returns a preview only.")
         .option("--draft-id <id>", "Email only: when approving an AI reply-agent draft, its id (marks it sent on success).")
         .option("--json", "Print a JSON envelope.")
@@ -4574,7 +4825,7 @@ export function createProgram() {
         .addCommand(new Command("mark-read")
         .description("Mark a conversation and all its messages as read.")
         .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
-        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default), whatsapp, or email.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
         await handleAsyncAction("inbox mark-read", options, () => {
@@ -4586,14 +4837,18 @@ export function createProgram() {
         });
     }))
         .addCommand(new Command("analyze")
-        .description("Run the default analysis on an email conversation now: sentiment + interest category + a drafted reply (Oxygen's default model). The worker also does this automatically on inbound mail.")
-        .argument("<conversation>", "Conversation id or Zapbox thread id.")
+        .description("Run analysis on a conversation now: status + sentiment + a drafted reply (Oxygen's default model). The worker also does this automatically on inbound conversations.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("inbox analyze", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/analyze`, {
-            method: "POST",
-            body: { channel: "email" },
-        }));
+        await handleAsyncAction("inbox analyze", options, () => {
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/analyze`, {
+                method: "POST",
+                body: { channel },
+            });
+        });
     }))
         .addCommand(new Command("archive")
         .description("Archive an email conversation (triage it out of the inbox). --unarchive restores it.")
@@ -4626,17 +4881,53 @@ export function createProgram() {
                 body.message_limit = Number(messageLimit);
             return requestOxygen("/api/cli/inbox/sync", { method: "POST", body });
         });
+    }))
+        .addCommand(new Command("backfill")
+        .description("Opt-in: pull a LinkedIn account's OLDER message history into the unibox. A SLOW, durable background drip walks each conversation's thread strictly backward — one page per worker tick under a dedicated conservative read budget — so a long history fills in over many days and never burns the account's limits. New messages keep arriving in real time via webhooks; this only backfills old history. No messages are sent and no Oxygen credits are charged.")
+        .option("--account <ref>", "Sender account to backfill (sender id, connection id, or Unipile account id). Omit to backfill every active LinkedIn account.")
+        .option("--conversation <ref>", "Scope to a single conversation (conversation id or Unipile chat id).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox backfill", options, () => {
+            const account = readOption(options.account);
+            const conversation = readOption(options.conversation);
+            return requestOxygen("/api/cli/linkedin/inbox/backfill", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(conversation ? { conversation } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("status")
-        .description("Set an email conversation's status (the Instantly-style tier). A manual override that locks out AI re-classification.")
-        .argument("<conversation>", "Conversation id or Zapbox thread id.")
+        .description("Set a conversation's status (the Instantly-style tier). A manual override that locks out AI re-classification. --channel linkedin/whatsapp sets a DM's status.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
         .argument("<status>", "A status label key (e.g. interested, meeting_booked, won, not_interested).")
+        .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, status, options) => {
-        await handleAsyncAction("inbox status", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/status`, {
-            method: "POST",
-            body: { status },
-        }));
+        await handleAsyncAction("inbox status", options, () => {
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/status`, {
+                method: "POST",
+                body: { status, channel },
+            });
+        });
+    }))
+        .addCommand(new Command("rescan")
+        .description("Re-queue conversations for AI re-classification (status + sentiment + drafted reply). Without --yes, previews the counts that would be re-flipped. With --yes, the worker re-classifies the pending rows (free for opt-outs, low-tier model otherwise, credit-capped).")
+        .option("--channel <channel>", "Inbox channel: all (default), email, linkedin, or whatsapp.")
+        .option("--yes", "Execute the re-queue. Without this flag, returns a preview of the counts only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox rescan", options, () => {
+            const channel = readOption(options.channel) ?? "all";
+            return requestOxygen("/api/cli/inbox/rescan", {
+                method: "POST",
+                body: { channel, confirm: Boolean(options.yes) },
+            });
+        });
     }))
         .addCommand(new Command("labels")
         .description("Manage inbox status labels (the Instantly-style system set + custom labels).")
@@ -4834,7 +5125,9 @@ export function createProgram() {
         .requiredOption("--name <name>", "Human-readable sequence name.")
         .requiredOption("--slug <slug>", "Unique slug for the sequence.")
         .requiredOption("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] }. LinkedIn steps (invite | message | wait_for_connection | inmail), email steps (email_send | email_reply | email_enroll | email_move | email_stop), and control steps (wait | wait_for_signal | branch | stop), each with an `id`. A `branch` routes on signals (then/else) or the legacy connection_accepted/already_connected sugar (then_id/else_id).")
-        .option("--channels <list>", "Comma-separated channels: linkedin,email. Defaults to the channels the journey touches.")
+        .option("--channels <list>", "Comma-separated channels: linkedin,email,whatsapp. Defaults to the channels the journey touches.")
+        .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live — WhatsApp via Unipile is unofficial WhatsApp Web, so cold-initiating is an explicit ban-risk opt-in.")
+        .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile).")
         .option("--senders <ids>", "Comma-separated LinkedIn sender account ids (or connection / Unipile ids). Required when the journey has LinkedIn steps.")
         .option("--table <id>", "Source table id whose rows supply {{column}} template values.")
         .option("--url-column <key>", "Column key holding each lead's LinkedIn URL/provider id.")
@@ -4881,7 +5174,9 @@ export function createProgram() {
         .argument("<sequence>", "Sequence id or slug.")
         .option("--name <name>", "New human-readable sequence name.")
         .option("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] } replacing the journey.")
-        .option("--channels <list>", "Comma-separated channels: linkedin,email.")
+        .option("--channels <list>", "Comma-separated channels: linkedin,email,whatsapp.")
+        .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live (draft-editable).")
+        .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile).")
         .option("--senders <ids>", "Comma-separated LinkedIn sender account ids (or connection / Unipile ids).")
         .option("--email-provider <provider>", "Email provider for the email track. Only 'instantly' is supported.")
         .option("--email-connection <id>", "Instantly connection id for the email track.")
@@ -9655,14 +9950,29 @@ options) {
     const timezone = readOption(options.timezone);
     if (timezone)
         workingHours.timezone = timezone;
+    // Warm-up override (LinkedIn only). A start-date wins over the booleans; the
+    // WhatsApp `set` command doesn't expose these flags, so this stays empty there.
+    let warmup;
+    const warmupStartDate = readOption(options.warmupStartDate);
+    if (warmupStartDate) {
+        warmup = { start_date: warmupStartDate };
+    }
+    else if (options.warmupDisable) {
+        warmup = { enabled: false };
+    }
+    else if (options.warmupRestart) {
+        warmup = { enabled: true };
+    }
     const hasLimits = Object.keys(limits).length > 0;
     const hasWorkingHours = Object.keys(workingHours).length > 0;
-    if (!hasLimits && !hasWorkingHours) {
-        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day) or --timezone.", { exitCode: 1 });
+    const hasWarmup = warmup !== undefined;
+    if (!hasLimits && !hasWorkingHours && !hasWarmup) {
+        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day), --timezone, or a warm-up flag (--warmup-restart / --warmup-disable / --warmup-start-date).", { exitCode: 1 });
     }
     return {
         ...(hasLimits ? { limits } : {}),
         ...(hasWorkingHours ? { working_hours: workingHours } : {}),
+        ...(hasWarmup ? { warmup } : {}),
     };
 }
 function readPositiveInt(value) {
@@ -9733,6 +10043,13 @@ function readSequenceSettings(options) {
     if (windowPath) {
         settings.email_send_window = readJsonFileValue(resolve(windowPath), "--send-window-file");
     }
+    if (options.whatsappColdInitiate === true) {
+        settings.whatsapp_cold_initiate = true;
+    }
+    const phoneColumnKey = readOption(options.phoneColumnKey);
+    if (phoneColumnKey) {
+        settings.phone_column_key = phoneColumnKey;
+    }
     return Object.keys(settings).length > 0 ? settings : undefined;
 }
 function muteTokenEcho() {

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
 export * from "./sql-error.js";
 export * from "./telemetry.js";
+export * from "./tenant-database-secret.js";
 export * from "./worker-failures-queue.js";
 export declare const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export type SemanticVersion = {

package/node_modules/@oxygen/shared/dist/index.js

@@ -15,6 +15,7 @@ export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
 export * from "./sql-error.js";
 export * from "./telemetry.js";
+export * from "./tenant-database-secret.js";
 export * from "./worker-failures-queue.js";
 // Maximum rows a single row-loop write (insert/upsert/preview) may process. The
 // row-loop engine issues one DB round-trip per row, so a 500-row write already

package/node_modules/@oxygen/shared/dist/sequences.d.ts

@@ -26,7 +26,7 @@
  * and inbox rotation while Oxygen owns the cross-channel timeline + reply
  * suppression.
  */
-export declare const SEQUENCE_CHANNELS: readonly ["linkedin", "email"];
+export declare const SEQUENCE_CHANNELS: readonly ["linkedin", "email", "whatsapp"];
 export type SequenceChannel = (typeof SEQUENCE_CHANNELS)[number];
 /**
  * Signals an enrollment accumulates from provider webhooks. wait_for_signal gates
@@ -48,6 +48,32 @@ export declare function isExternalSequenceSignal(value: string): value is Sequen
  * Single source of truth so the send path and the lookup path can't drift.
  */
 export declare const SEQUENCE_EMAIL_COLUMN_KEYS: readonly ["email", "email_address", "work_email", "primary_email", "Email"];
+/**
+ * row_values keys an enrollment's phone number may live under, in
+ * send-precedence order, for WhatsApp sends. The enroll path resolves the FIRST
+ * present key to a Unipile WhatsApp attendee id (E.164). Mirrors
+ * SEQUENCE_EMAIL_COLUMN_KEYS so the WhatsApp send + lookup paths can't drift.
+ */
+export declare const SEQUENCE_PHONE_COLUMN_KEYS: readonly ["phone", "phone_number", "mobile", "mobile_phone", "Phone"];
+/**
+ * Normalize a raw phone number to the attendee id Unipile's WhatsApp
+ * `chats_create` accepts (E.164 digits — no '+', spaces, or separators). Returns
+ * null for an implausibly short/long number.
+ *
+ * NOTE (R1 — the one unconfirmed Unipile contract): the exact attendee format
+ * Unipile wants to open a COLD WhatsApp chat is the single thing to confirm
+ * against a live WhatsApp account. If Unipile needs a different shape (a resolved
+ * attendee id, or a "<digits>@s.whatsapp.net" jid), THIS function is the only
+ * seam to change — every caller routes through it.
+ */
+export declare function whatsAppAttendeeIdForPhone(phone: string): string | null;
+/**
+ * Resolve a lead's WhatsApp attendee id from its row_values: read the configured
+ * phone column (or fall back to SEQUENCE_PHONE_COLUMN_KEYS in precedence order),
+ * then normalize via whatsAppAttendeeIdForPhone. Single source of truth so the
+ * enroll/plan path and any preview count can't drift.
+ */
+export declare function whatsAppAttendeeIdFromRow(rowValues: Record<string, unknown> | null | undefined, phoneColumnKey?: string | null): string | null;
 /**
  * A per-step / per-sequence send window. `days` are ISO weekdays (1=Mon … 7=Sun)
  * on which sends are allowed; `start`/`end` are "HH:MM" local times. The window
@@ -73,7 +99,7 @@ export type SequenceSendWindow = {
 };
 /** Base content + up to this many alternates per A/B step (base counts as variant "a"). */
 export declare const MAX_STEP_VARIANTS = 5;
-export declare const SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "message", "inmail", "email_send", "email_reply", "email_enroll", "email_move", "email_stop", "wait", "wait_for_signal", "branch", "stop"];
+export declare const SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "message", "inmail", "email_send", "email_reply", "email_enroll", "email_move", "email_stop", "whatsapp_message", "wait", "wait_for_signal", "branch", "stop"];
 export type SequenceStepKind = (typeof SEQUENCE_STEP_KINDS)[number];
 export type SequenceLinkedInVisitProfileStep = {
     id: string;
@@ -169,6 +195,23 @@ export type SequenceEmailReplyStep = {
     /** Per-step send window (overrides the sequence-level email_send_window). */
     send_window?: SequenceSendWindow;
 };
+/**
+ * Native WhatsApp message send through one of the sequence's WhatsApp senders
+ * (Unipile chats_messages_send into an existing chat, else chats_create to open
+ * one). Oxygen owns the send; the WhatsApp warm-up ramp + per-account daily caps
+ * bound throughput. Cold first-touch (no existing chat with the lead) requires
+ * the sequence's whatsapp_cold_initiate opt-in, enforced at start + dispatch.
+ */
+export type SequenceWhatsAppMessageStep = {
+    id: string;
+    channel: "whatsapp";
+    kind: "whatsapp_message";
+    template: string;
+    /** A/B alternates. Each overrides the base `template`; the base is variant "a". */
+    variants?: {
+        template?: string;
+    }[];
+};
 export type SequenceWaitStep = {
     id: string;
     kind: "wait";
@@ -251,7 +294,7 @@ export type SequenceSignalCondition = {
 } | {
     not: SequenceSignalCondition;
 };
-export type SequenceStep = SequenceLinkedInVisitProfileStep | SequenceLinkedInInviteStep | SequenceLinkedInWaitForConnectionStep | SequenceLinkedInMessageStep | SequenceLinkedInInMailStep | SequenceEmailSendStep | SequenceEmailReplyStep | SequenceEmailEnrollStep | SequenceEmailMoveStep | SequenceEmailStopStep | SequenceWaitStep | SequenceWaitForSignalStep | SequenceBranchStep | SequenceStopStep;
+export type SequenceStep = SequenceLinkedInVisitProfileStep | SequenceLinkedInInviteStep | SequenceLinkedInWaitForConnectionStep | SequenceLinkedInMessageStep | SequenceLinkedInInMailStep | SequenceEmailSendStep | SequenceEmailReplyStep | SequenceEmailEnrollStep | SequenceEmailMoveStep | SequenceEmailStopStep | SequenceWhatsAppMessageStep | SequenceWaitStep | SequenceWaitForSignalStep | SequenceBranchStep | SequenceStopStep;
 export type SequenceDefinition = {
     steps: SequenceStep[];
 };

package/node_modules/@oxygen/shared/dist/sequences.js

@@ -28,7 +28,7 @@ import { renderLinkedInTemplate } from "./linkedin-sequences.js";
  * and inbox rotation while Oxygen owns the cross-channel timeline + reply
  * suppression.
  */
-export const SEQUENCE_CHANNELS = ["linkedin", "email"];
+export const SEQUENCE_CHANNELS = ["linkedin", "email", "whatsapp"];
 /**
  * Signals an enrollment accumulates from provider webhooks. wait_for_signal gates
  * and signal-branch conditions read these. linkedin_connected also advances the
@@ -77,6 +77,50 @@ export function isExternalSequenceSignal(value) {
  * Single source of truth so the send path and the lookup path can't drift.
  */
 export const SEQUENCE_EMAIL_COLUMN_KEYS = ["email", "email_address", "work_email", "primary_email", "Email"];
+/**
+ * row_values keys an enrollment's phone number may live under, in
+ * send-precedence order, for WhatsApp sends. The enroll path resolves the FIRST
+ * present key to a Unipile WhatsApp attendee id (E.164). Mirrors
+ * SEQUENCE_EMAIL_COLUMN_KEYS so the WhatsApp send + lookup paths can't drift.
+ */
+export const SEQUENCE_PHONE_COLUMN_KEYS = ["phone", "phone_number", "mobile", "mobile_phone", "Phone"];
+/**
+ * Normalize a raw phone number to the attendee id Unipile's WhatsApp
+ * `chats_create` accepts (E.164 digits — no '+', spaces, or separators). Returns
+ * null for an implausibly short/long number.
+ *
+ * NOTE (R1 — the one unconfirmed Unipile contract): the exact attendee format
+ * Unipile wants to open a COLD WhatsApp chat is the single thing to confirm
+ * against a live WhatsApp account. If Unipile needs a different shape (a resolved
+ * attendee id, or a "<digits>@s.whatsapp.net" jid), THIS function is the only
+ * seam to change — every caller routes through it.
+ */
+export function whatsAppAttendeeIdForPhone(phone) {
+    const digits = phone.trim().replace(/[^\d]/g, "");
+    if (digits.length < 7 || digits.length > 15)
+        return null;
+    return digits;
+}
+/**
+ * Resolve a lead's WhatsApp attendee id from its row_values: read the configured
+ * phone column (or fall back to SEQUENCE_PHONE_COLUMN_KEYS in precedence order),
+ * then normalize via whatsAppAttendeeIdForPhone. Single source of truth so the
+ * enroll/plan path and any preview count can't drift.
+ */
+export function whatsAppAttendeeIdFromRow(rowValues, phoneColumnKey) {
+    if (!rowValues)
+        return null;
+    const keys = phoneColumnKey ? [phoneColumnKey, ...SEQUENCE_PHONE_COLUMN_KEYS] : [...SEQUENCE_PHONE_COLUMN_KEYS];
+    for (const key of keys) {
+        const value = rowValues[key];
+        if (typeof value === "string" && value.trim()) {
+            const attendee = whatsAppAttendeeIdForPhone(value);
+            if (attendee)
+                return attendee;
+        }
+    }
+    return null;
+}
 /** Base content + up to this many alternates per A/B step (base counts as variant "a"). */
 export const MAX_STEP_VARIANTS = 5;
 export const SEQUENCE_STEP_KINDS = [
@@ -92,6 +136,8 @@ export const SEQUENCE_STEP_KINDS = [
     "email_enroll",
     "email_move",
     "email_stop",
+    // whatsapp channel (native dispatch via Unipile)
+    "whatsapp_message",
     // control (channel-agnostic)
     "wait",
     "wait_for_signal",
@@ -294,6 +340,14 @@ raw, index, options, issues) {
         }
         case "email_stop":
             return { id, channel: "email", kind: "email_stop" };
+        case "whatsapp_message": {
+            const template = requiredTemplate(raw.template, `${path}.template`, issues);
+            const variants = normalizeVariants(raw.variants, `${path}.variants`, ["template"], issues);
+            return {
+                id, channel: "whatsapp", kind: "whatsapp_message", template: template ?? "",
+                ...(variants ? { variants: variants } : {}),
+            };
+        }
         case "wait": {
             const days = optionalNonNegativeInt(raw.days, `${path}.days`, issues);
             const hours = optionalNonNegativeInt(raw.hours, `${path}.hours`, issues);
@@ -370,6 +424,8 @@ function channelForKind(kind) {
     if (kind === "email_send" || kind === "email_reply" ||
         kind === "email_enroll" || kind === "email_move" || kind === "email_stop")
         return "email";
+    if (kind === "whatsapp_message")
+        return "whatsapp";
     return "linkedin";
 }
 function normalizeId(value, index, path, issues) {
@@ -557,6 +613,7 @@ function baseVariantContent(step) {
         case "email_send": return { subject_template: step.subject_template, body_template: step.body_template };
         case "email_reply": return { body_template: step.body_template };
         case "message": return { template: step.template };
+        case "whatsapp_message": return { template: step.template };
         case "inmail": return { subject_template: step.subject_template, template: step.template };
         default: return null;
     }

package/node_modules/@oxygen/shared/dist/tenant-database-secret.d.ts

@@ -0,0 +1 @@
+export declare function resolveTenantDatabaseSecretKey(): string;

package/node_modules/@oxygen/shared/dist/tenant-database-secret.js

@@ -0,0 +1,12 @@
+import { OxygenError } from "./cli-result.js";
+export function resolveTenantDatabaseSecretKey() {
+    const key = process.env.TENANT_DATABASE_SECRET_KEY ??
+        process.env.INTEGRATION_SECRET_KEY;
+    if (!key) {
+        throw new OxygenError("tenant_database_secret_key_missing", "TENANT_DATABASE_SECRET_KEY is not set.", {
+            details: { env: "TENANT_DATABASE_SECRET_KEY" },
+            exitCode: 1,
+        });
+    }
+    return key;
+}

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const OXYGEN_VERSION = "1.209.6";
+export declare const OXYGEN_VERSION = "1.218.5";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.209.6";
+export const OXYGEN_VERSION = "1.218.5";
 // Bump this only when deployed CLI/API contracts require a newer CLI.
 // 1.181.0: paid table action runs and background columns run require
 // approved=true in addition to max_credits; older CLIs cannot send the flag.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.209.6",
+  "version": "1.218.5",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",