@oxygen-agent/cli 1.1014.135 → 1.1014.618

package/dist/commands/inbox.js

@@ -0,0 +1,779 @@
+import { readNonNegativeInt, readRecordString } from "../cli-values.js";
+import { collectRepeatable, splitCommaList } from "../command-support.js";
+import { addContractFlags, readContractFlags } from "../contract-flags.js";
+import { requestOxygen } from "../http-client.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { INBOX_DRAFTS_READ_CONTRACT } from "@oxygen/shared/contracts/inbox-drafts-read";
+import { Command, Option } from "commander";
+export function registerInboxFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("inbox")
+        .description("Unified inbox (unibox): private email + LinkedIn DM + WhatsApp conversations in one stream (the default), or a single channel with --channel; `get` and `send` resolve a conversation's channel from its id. Public comments on owned LinkedIn posts are not inbox messages; use `publishing comments`. Scan, read, reply, or start a WhatsApp chat.")
+        .addCommand(new Command("list")
+        .description("List conversations newest first across email, LinkedIn, and WhatsApp — the merged stream is the default, --channels narrows it, and --channel email/linkedin/whatsapp lists a single channel. Primary excludes the negative tier (not_now, not_interested, lost, bounced); All includes every ordinary conversation. Background AI reply triage sets each conversation's status, so triage is a filter, not a script: `--status interested` is positive sales intent, `--status not_interested` is who said no, and `--unanswered` only means the last message is theirs. None of them means a thread needs a reply: interested includes thank-yous and booking confirmations, and neutral can hold real questions. A reply that just arrived can read neutral until it is analyzed (`inbox analyze <id>` classifies one now). In --json, `count` is the rows on this page (follow next_cursor for more); on email, `total_conversations` and the `sidebar_counts` facets are mailbox-wide and do not apply your filters, so never read them as the size of a filtered list.")
+        .option("--channel <channel>", "Inbox channel: all (default, the merged stream), email, linkedin, or whatsapp.")
+        .option("--channels <list>", "Narrow the merged stream: comma-separated channel groups to include (email,linkedin,whatsapp). Implies --channel all.")
+        .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("--unanswered", "Only conversations you have not replied to — the last message in the thread is inbound. Not the same as needing a reply: it keeps thank-yous and automated mail. Cross-channel. Off by default in the CLI and web Unibox: an unfiltered list still shows answered threads. It includes inbound mail no campaign sent — unsolicited or spam — so for replies to your outreach add --sequence-id; the ids and per-campaign counts are in sidebar_counts.byCampaign of the same --json response.")
+        // Hidden while the AI inbox triage is dev-only (ADR 0027): production
+        // help must not offer a flag its API refuses. Unhide with the flag's
+        // production rollout.
+        .addOption(new Option("--needs-reply", "Narrower than --unanswered: unanswered threads minus those AI inbox triage judged bulk (newsletters, notifications, mass pitches) or needing no answer. Threads not yet analysed stay in: each row carries `triage_status` (analysed, undecided or not_analysed) next to `triage`, and `needs_reply_counts` sizes the whole list. `inbox analyze <id> --force` analyses one now. Ignored while --search is set. Only where AI inbox triage is enabled; elsewhere the API answers needs_reply_unavailable.").hideHelp())
+        .option("--responses-only", "Email only: only conversations with an inbound reply (never sent-only threads).")
+        .option("--bucket <bucket>", "Email only: primary or others (superseded by --segment).")
+        .option("--segment <segment>", "Top tab: primary (everything but the negative status tier), all, or an email-only folder (others, sent, warmup, dmarc).")
+        .option("--status <keys>", "Comma-separated reply-status keys, set by AI reply triage. System keys: interested, neutral, out_of_office, wrong_person, not_now, not_interested, lost, bounced; your workspace's full list, custom labels included, is `inbox labels list`. Cross-channel — filters email + LinkedIn + WhatsApp by the shared taxonomy.")
+        .option("--tag <tags>", "Comma-separated campaign tags — matches email conversations whose campaign (sequence) carries any of these tags. DMs have no campaign link, so a tag filter shows email only.")
+        .option("--since <iso>", "Only conversations whose last message is on/after this ISO date/timestamp. Excludes conversations without a last-message date. Cross-channel.")
+        .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Excludes conversations without a last-message date. Cross-channel.")
+        .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) UUIDs (not slugs — `sequences list` shows each campaign's id). Returns only conversations linked to that campaign; `sidebar_counts.byCampaign` is its size.")
+        .option("--provider <providers>", "Email only: comma-separated providers (google,microsoft).")
+        .option("--domain <domains>", "Email only: comma-separated counterpart domains to include.")
+        .option("--exclude-domain <domains>", "Email only: comma-separated counterpart domains to exclude.")
+        .option("--mailbox-id <ids>", "Email only: comma-separated mailbox ids.")
+        .option("--sender-profile-id <ids>", "Comma-separated sender profile ids (people; `unibox metadata` and `senders profiles list` list them): only conversations on their own inboxes and LinkedIn/WhatsApp accounts. The same `sender_profile_id` key a saved view's --filters takes. Merged stream only; narrow channels with --channels.")
+        .addOption(new Option("--sender-profile <ids>", "Alias of --sender-profile-id.").hideHelp())
+        .option("--search <text>", "Fuzzy search (typos, word order, prefixes) over names, addresses, subjects and the text of every message in EVERY non-warmup conversation: all channels unless --channel narrows, archived and sent-only threads included. --segment, --unanswered and the Primary tab's negative-tier exclusion are ignored while set; explicit facets such as --status still narrow. For structured filters use --status or --tag, not a text search.")
+        .option("--include-archived", "Include archived conversations.")
+        .option("--limit <n>", "Maximum conversations to return (1-200). Defaults to 50.")
+        .option("--cursor <cursor>", "Merged stream only: the previous page's next_cursor — resumes after that row.")
+        .option("--no-counts", "channel=all only: skip the sidebar facet counts for a faster paged read (total_conversations/unread_conversations/sidebar_counts omitted from the envelope). Other channels ignore it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox list", options, () => {
+            const params = new URLSearchParams();
+            const channel = readOption(options.channel);
+            if (channel)
+                params.set("channel", channel);
+            const account = readOption(options.account);
+            if (account)
+                params.set("account", account);
+            if (options.unread)
+                params.set("unread", "true");
+            if (options.unanswered)
+                params.set("unanswered", "true");
+            if (options.needsReply)
+                params.set("needs_reply", "true");
+            if (options.responsesOnly)
+                params.set("responses_only", "true");
+            for (const [flag, key] of [
+                ["bucket", "bucket"],
+                ["segment", "segment"],
+                ["channels", "channels"],
+                ["status", "status"],
+                ["tag", "tag"],
+                ["since", "since"],
+                ["until", "until"],
+                ["sequenceId", "sequence_id"],
+                ["provider", "provider"],
+                ["domain", "domain"],
+                ["excludeDomain", "exclude_domain"],
+                ["mailboxId", "mailbox_id"],
+                ["senderProfile", "sender_profile_id"],
+                ["senderProfileId", "sender_profile_id"],
+                ["cursor", "cursor"],
+            ]) {
+                const value = readOption(options[flag]);
+                if (value)
+                    params.set(key, value);
+            }
+            const search = readOption(options.search);
+            if (search)
+                params.set("search", search);
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            // Commander's --no-counts sets counts:false; absent leaves the
+            // server default (counts included) untouched.
+            if (options.counts === false)
+                params.set("include_counts", "false");
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/inbox${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .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, and is resolved on any channel by default (email first, then LinkedIn/WhatsApp). Opening a LinkedIn or WhatsApp thread may fetch provider history and update the local mirror. WhatsApp also merges provider-confirmed phone/contact identities. This uses no Oxygen credits and sends no message; old conversation references remain usable. Use --stored-only to read the mirror without provider refresh. --sender-account-id retains that participant’s DM privacy window.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or Zapbox thread id.")
+        .option("--channel <channel>", "Inbox channel: all (default, resolves the id on any channel), email, linkedin, or whatsapp.")
+        .option("--message-limit <n>", "Maximum messages to return (1-500). Defaults to 100.")
+        .option("--sender-account-id <ids>", "Scope DM history to participant UUIDs, comma-separated.")
+        .option("--stored-only", "Read mirrored messages without provider refresh.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox get", options, () => {
+            const params = new URLSearchParams();
+            const channel = readOption(options.channel);
+            if (channel)
+                params.set("channel", channel);
+            const messageLimit = readOption(options.messageLimit);
+            if (messageLimit)
+                params.set("message_limit", messageLimit);
+            const senderAccountId = readOption(options.senderAccountId);
+            if (senderAccountId)
+                params.set("sender_account_id", senderAccountId);
+            if (options.storedOnly)
+                params.set("sync", "0");
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("send")
+        .description("Reply into a conversation on its own channel, resolved from the conversation when --channel is omitted: an email thread replies from its own mailbox (Zapbox/native Gmail/Graph, threaded); a WhatsApp thread gets a warm reply; a LinkedIn thread replies via Unipile. Shared LinkedIn threads require --sender-account-id. 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>", "Optional: email, linkedin, or whatsapp. Resolved from the conversation when omitted.")
+        .option("--sender-account-id <id>", "LinkedIn participant UUID from the thread’s senderAccountIds. Required for a shared thread.")
+        .option("--approved", "Approve and send the message. Without this flag, returns a preview only.")
+        .option("--draft-id <id>", "When approving an AI reply-agent draft (email or LinkedIn), its id (marks it sent on success). Use the matching --channel.")
+        .option("--attach <path-or-url>", "Email: local PDF, DOCX, XLSX, PPTX, TXT, or CSV path; preview uploads it for 24 hours without sending. LinkedIn: public URL. Repeatable, up to 5 files and 10 MiB total for email.", collectRepeatable, [])
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox send", options, async () => {
+            let channel = readOption(options.channel);
+            const draftId = readOption(options.draftId);
+            const attached = (options.attach ?? []).map((value) => value.trim()).filter(Boolean);
+            if (attached.length > 5)
+                throw new OxygenError("invalid_attachments", "Attach up to five files.", { exitCode: 1 });
+            if (attached.length && !channel) {
+                const detail = await requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}`);
+                channel = readRecordString(detail, "channel");
+            }
+            const attachments = channel === "linkedin" ? attached.map((url) => ({ url })) : [];
+            const attachmentIds = [];
+            if (attached.length && channel === "email") {
+                const { readFile, stat } = await import("node:fs/promises");
+                const { basename } = await import("node:path");
+                const { createHash } = await import("node:crypto");
+                let totalBytes = 0;
+                const base = `/api/cli/inbox/${encodeURIComponent(conversation)}/attachments`;
+                for (const filePath of attached) {
+                    const info = await stat(filePath);
+                    totalBytes += info.size;
+                    if (!info.isFile() || info.size < 1 || totalBytes > 10 * 1024 * 1024) {
+                        throw new OxygenError("attachment_size_invalid", "Email attachments must be files totaling at most 10 MiB.", { exitCode: 1 });
+                    }
+                    const bytes = await readFile(filePath);
+                    const ticket = await requestOxygen(`${base}/upload-url`, {
+                        method: "POST", body: { name: basename(filePath), byte_length: bytes.byteLength,
+                            sha256: createHash("sha256").update(bytes).digest("hex") },
+                    });
+                    const uploadUrl = readRecordString(ticket, "upload_url");
+                    const file = ticket.file;
+                    const fileId = file && typeof file === "object" && !Array.isArray(file)
+                        ? readRecordString(file, "id") : null;
+                    if (!uploadUrl || !fileId)
+                        throw new OxygenError("attachment_upload_failed", "The server did not return a complete upload ticket.", { exitCode: 1 });
+                    const put = await fetch(uploadUrl, { method: "PUT", headers: {
+                            "content-type": readRecordString(ticket, "upload_content_type") ?? "application/octet-stream",
+                        }, body: new Uint8Array(bytes) });
+                    if (!put.ok)
+                        throw new OxygenError("attachment_upload_failed", `Object storage rejected the upload (${put.status}).`, { exitCode: 1 });
+                    await requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/attachments/${encodeURIComponent(fileId)}/uploaded`, {
+                        method: "POST", body: {},
+                    });
+                    attachmentIds.push(fileId);
+                }
+            }
+            else if (attached.length && channel !== "linkedin") {
+                throw new OxygenError("attachments_unsupported", "Files can only be attached to email replies or LinkedIn public URLs.", { exitCode: 1 });
+            }
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/send`, {
+                method: "POST",
+                body: {
+                    text: readOption(options.text),
+                    ...(channel ? { channel } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                    ...(draftId ? { draft_id: draftId } : {}),
+                    ...(readOption(options.senderAccountId) ? { sender_account_id: readOption(options.senderAccountId) } : {}),
+                    ...(attachments.length > 0 ? { attachments } : {}),
+                    ...(attachmentIds.length > 0 ? { attachment_ids: attachmentIds } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("start-whatsapp")
+        .description("Start a one-to-one WhatsApp chat from the Unibox. Choose a connected sender and either a phone with country code or a CRM person row id. Without --approved, preview the exact recipient and first message. Cold chats use an unofficial linked-device connection and can increase account restriction risk.")
+        .requiredOption("--sender <id>", "Connected WhatsApp sender account id.")
+        .option("--phone <number>", "Recipient phone with country code, e.g. +14155550142.")
+        .option("--person-row-id <id>", "CRM people record row id; uses that person's phone.")
+        .requiredOption("--text <message>", "First message to send.")
+        .option("--approved", "Approve and send the WhatsApp message. Without this flag, returns a preview.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox start-whatsapp", options, () => requestOxygen("/api/cli/inbox/whatsapp/start", {
+            method: "POST",
+            body: { sender_account_id: readOption(options.sender),
+                ...(options.phone ? { phone: readOption(options.phone) } : {}),
+                ...(options.personRowId ? { person_row_id: readOption(options.personRowId) } : {}),
+                text: readOption(options.text), ...(options.approved ? { approved: true } : {}) },
+        }));
+    }))
+        .addCommand(new Command("forget-whatsapp-chat")
+        .description("Permanently erase a terminal old WhatsApp chat and its messages from OXYGEN. Preview first; --approved confirms the exact chat. --sender and --before guard the scope. This does not delete from WhatsApp; for a connected account find whatsapp.chats_delete with oxygen tools search, inspect tools run --mode dry-run, then use --mode live --approved and verify the provider result.")
+        .argument("<conversationId>", "OXYGEN conversation id from inbox list.")
+        .requiredOption("--sender <id>", "Original disconnected WhatsApp sender account id.")
+        .requiredOption("--before <iso>", "Delete only when the latest message predates this ISO timestamp.")
+        .option("--approved", "Approve permanent removal from OXYGEN after reviewing the preview.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversationId, options) => {
+        await handleAsyncAction("inbox forget-whatsapp-chat", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversationId)}/forget-whatsapp`, {
+            method: "POST",
+            body: { sender_account_id: readOption(options.sender), before: readOption(options.before),
+                approved: options.approved === true },
+        }));
+    }))
+        .addCommand(new Command("delete-message")
+        .description("Delete your sent LinkedIn message for everyone within 60 minutes. This cannot be undone. Omit --approved for a preview; show it before approving. Other channels and inbound messages are unsupported.")
+        .argument("<conversationId>", "Oxygen conversation id from inbox get.")
+        .argument("<messageId>", "Oxygen message id from inbox get.")
+        .option("--approved", "Approve permanent deletion of this exact message after reviewing the preview.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversationId, messageId, options) => {
+        await handleAsyncAction("inbox delete-message", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}/delete`, {
+            method: "POST",
+            body: { approved: options.approved === true },
+        }));
+    }))
+        .addCommand(new Command("mark-read")
+        .description("Mark visible messages in a conversation as read (LinkedIn by default; use --channel email or whatsapp for those channels). Sender filters retain the selected DM history window.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default), whatsapp, or email.")
+        .option("--sender-account-id <ids>", "Scope DM read state to participant UUIDs, comma-separated.")
+        .option("--sender-profile-id <ids>", "Scope DM read state to sender profile UUIDs, comma-separated.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox mark-read", options, () => {
+            const channel = readOption(options.channel);
+            const params = new URLSearchParams();
+            const senderAccountId = readOption(options.senderAccountId), senderProfileId = readOption(options.senderProfileId);
+            if (senderAccountId)
+                params.set("sender_account_id", senderAccountId);
+            if (senderProfileId)
+                params.set("sender_profile_id", senderProfileId);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/read${suffix ? `?${suffix}` : ""}`, {
+                method: "POST",
+                body: channel ? { channel } : {},
+            });
+        });
+    }))
+        .addCommand(new Command("mark-all-read")
+        .description("Mark EVERY conversation matching the filters as read — the whole filtered set across email + LinkedIn + WhatsApp, not just the conversations on the page you can see. Two phases: WITHOUT --yes it only previews (returns the unread count those filters would mark and changes nothing); WITH --yes it marks them read. The filter flags below are the same ones `inbox list` takes, so the scope is exactly what `inbox list --channel all` would show — run that first to see it. Large sets are marked in batches: when the response comes back with has_more true, re-run the same command to continue. Free — no credits, no external writes.")
+        .option("--channels <list>", "Comma-separated channel groups to include (email,linkedin,whatsapp). Empty = all three.")
+        .option("--segment <segment>", "Which folder to sweep: all (the default), primary, others, sent, warmup, or dmarc. all and primary are cross-channel; others, sent, warmup and dmarc are email-only folders. NOTE the default is not 'everything': all is the merged reply stream, so it already excludes warmup mail, DMARC reports, bounced threads, and threads you have only sent to — a bare run leaves those untouched; sweep them with --segment warmup / dmarc / sent / others. primary is narrower still: it also drops the negative status tier (not_now, not_interested, lost, bounced).")
+        .option("--status <keys>", "Comma-separated status keys (e.g. interested,meeting_booked). Cross-channel.")
+        .option("--tag <tags>", "Comma-separated campaign tags — matches email conversations whose campaign (sequence) carries any of these tags. DMs have no campaign link, so a tag filter scopes the sweep to email.")
+        .option("--sequence-id <ids>", "Email only: comma-separated campaign (sequence) UUIDs (not slugs — get the id from `sequences get <slug>`).")
+        .option("--provider <providers>", "Email only: comma-separated providers (google,microsoft).")
+        .option("--domain <domains>", "Email only: comma-separated counterpart domains to include.")
+        .option("--exclude-domain <domains>", "Email only: comma-separated counterpart domains to exclude.")
+        .option("--mailbox-id <ids>", "Email only: comma-separated mailbox ids.")
+        .option("--sender-account-id <ids>", "DMs only: comma-separated OXYGEN sender UUIDs from `oxygen senders list --json` (not LinkedIn member ids).")
+        .option("--sender-profile-id <ids>", "Comma-separated sender profile ids (people; `unibox metadata` lists them): only their own inboxes and LinkedIn/WhatsApp accounts, as in `inbox list --sender-profile-id`.")
+        .addOption(new Option("--sender-profile <ids>", "Alias of --sender-profile-id.").hideHelp())
+        .option("--since <iso>", "Only conversations whose last message is on/after this ISO date/timestamp. Excludes conversations without a last-message date. Cross-channel.")
+        .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Excludes conversations without a last-message date. Cross-channel.")
+        .option("--search <text>", "Fuzzy search (typos, word order, prefixes) over names, addresses, subjects and the text of every message in EVERY non-warmup conversation: all channels unless --channel narrows, archived and sent-only threads included. --segment, --unanswered and the Primary tab's negative-tier exclusion are ignored while set; explicit facets such as --status still narrow.")
+        .option("--include-archived", "Also mark archived conversations read.")
+        .option("--unanswered", "Only sweep conversations you have not replied to (the last message is inbound) — the same filter as `inbox list --unanswered`, so the scope is exactly that list.")
+        // Hidden with `inbox list --needs-reply`; see there.
+        .addOption(new Option("--needs-reply", "Only sweep the `inbox list --needs-reply` set (where AI inbox triage is enabled). Ignored while --search is set.").hideHelp())
+        .option("--yes", "Apply the sweep. Without this flag, returns a preview of the unread count only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox mark-all-read", options, () => {
+            // The sweep is always cross-channel: `channel=all` selects the
+            // merged stream `inbox list --channel all` reads, and --channels
+            // narrows it from there. The filters ride on the query string in
+            // the identical vocabulary as that GET — same parser server-side,
+            // so the sweep means exactly what the list means.
+            const params = new URLSearchParams();
+            params.set("channel", "all");
+            for (const [flag, key] of [
+                ["channels", "channels"],
+                ["segment", "segment"],
+                ["status", "status"],
+                ["tag", "tag"],
+                ["sequenceId", "sequence_id"],
+                ["provider", "provider"],
+                ["domain", "domain"],
+                ["excludeDomain", "exclude_domain"],
+                ["mailboxId", "mailbox_id"],
+                ["senderAccountId", "sender_account_id"],
+                ["senderProfile", "sender_profile_id"],
+                ["senderProfileId", "sender_profile_id"],
+                ["since", "since"],
+                ["until", "until"],
+                ["search", "search"],
+            ]) {
+                const value = readOption(options[flag]);
+                if (value)
+                    params.set(key, value);
+            }
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            // Booleans need their own line: the tuple loop above only walks
+            // the string-valued options.
+            if (options.unanswered)
+                params.set("unanswered", "true");
+            if (options.needsReply)
+                params.set("needs_reply", "true");
+            return requestOxygen(`/api/cli/inbox/read-all?${params.toString()}`, {
+                method: "POST",
+                previewOnly: !options.yes,
+                // Approval rides in the body: a bodyless POST reads as
+                // approved=false server-side, i.e. a preview that mutates
+                // nothing. --yes (not --approved) because this spends no
+                // credits — see MUTATING_VERBS in command-manifest.ts.
+                body: options.yes ? { approved: true } : {},
+            });
+        });
+    }))
+        .addCommand(new Command("analyze")
+        .description("Run analysis on a conversation now: status + 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("--force", "Re-analyze even if the conversation was already classified (an explicit paid re-classification; spends one managed credit). Without it, an already-analyzed email is a free no-op. DMs always re-analyze.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox analyze", options, () => {
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/analyze`, {
+                method: "POST",
+                body: { channel, ...(options.force ? { force: true } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a conversation (triage it out of the inbox). --unarchive restores it. --channel linkedin/whatsapp archives a DM.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
+        .option("--unarchive", "Restore the conversation instead of archiving it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox archive", options, () => {
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/archive`, {
+                method: "POST",
+                body: { channel, archived: !options.unarchive },
+            });
+        });
+    }))
+        .addCommand(new Command("sync")
+        .description("Force a backstop inbox sync from Unipile for the active LinkedIn and WhatsApp sender accounts (pulls recent chats + messages into the unibox). Email mailboxes are not synced here: they are polled automatically every worker tick, so email replies reach `inbox list` on their own.")
+        .option("--account <id>", "Force-sync one sender account (sender id, connection id, or Unipile account id).")
+        .option("--chat-limit <n>", "Maximum chats to sync per account. Defaults to 30.")
+        .option("--message-limit <n>", "Maximum messages to sync per chat. Defaults to 20.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox sync", options, () => {
+            const body = {};
+            const account = readOption(options.account);
+            if (account)
+                body.account = account;
+            const chatLimit = readOption(options.chatLimit);
+            if (chatLimit)
+                body.chat_limit = Number(chatLimit);
+            const messageLimit = readOption(options.messageLimit);
+            if (messageLimit)
+                body.message_limit = Number(messageLimit);
+            return requestOxygen("/api/cli/inbox/sync", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("backfill")
+        .description("Opt-in, LinkedIn only: 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. --cancel stops an armed drip. 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("--cancel", "Cancel the active history backfill drip for --account (or every LinkedIn account) instead of arming one. Messages already mirrored stay.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox backfill", options, () => {
+            const account = readOption(options.account);
+            const conversation = readOption(options.conversation);
+            if (options.cancel) {
+                if (conversation) {
+                    throw new OxygenError("invalid_request", "--cancel stops a sender's whole drip; it cannot be combined with --conversation. Pass --account (or nothing) with --cancel.", { exitCode: 1 });
+                }
+                return requestOxygen("/api/cli/linkedin/inbox/backfill/cancel", {
+                    method: "POST",
+                    body: { ...(account ? { account } : {}) },
+                });
+            }
+            return requestOxygen("/api/cli/linkedin/inbox/backfill", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(conversation ? { conversation } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .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("--source <manual|ai>", "Classification provenance; manual locks out AI reclassification.")
+        .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, () => {
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/status`, {
+                method: "POST",
+                body: { status, channel, ...(readOption(options.source) ? { source: readOption(options.source) } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("tag")
+        .description("Add/remove workspace tags on a conversation (Tags primitive — the same vocabulary as sequences, tables, posts; see `oxygen tags list`). Delta semantics: --add unions, --remove subtracts, remove wins on conflict. Internal metadata, never sent to the counterpart. --channel linkedin/whatsapp tags a DM conversation.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .option("--add <tags>", "Comma-separated tags to add.")
+        .option("--remove <tags>", "Comma-separated tags to remove.")
+        .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox tag", options, () => {
+            const add = splitCommaList(options.add);
+            const remove = splitCommaList(options.remove);
+            if (add.length === 0 && remove.length === 0) {
+                throw new OxygenError("invalid_request", "Pass --add and/or --remove.", { exitCode: 1 });
+            }
+            const channel = readOption(options.channel) ?? "email";
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/tags`, {
+                method: "POST",
+                body: {
+                    ...(add.length > 0 ? { add } : {}),
+                    ...(remove.length > 0 ? { remove } : {}),
+                    channel,
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("rescan")
+        .description("Re-queue conversations for AI re-classification (status + 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("bulk")
+        .description("Bulk-apply one triage action — set-status / archive / unarchive — across up to 100 hand-picked conversations (the ids `inbox list` returns) in one call. Without --yes, previews the matched/would-change counts (no mutation). With --yes, applies it. --channel scopes the ids (email default; run once per channel).")
+        .requiredOption("--action <action>", "set-status, archive, or unarchive.")
+        .requiredOption("--ids <ids>", "Comma-separated conversation ids (the uuids `inbox list` returns). Max 100.")
+        .option("--status <key>", "Required for --action set-status: the status label key to set (e.g. interested).")
+        .option("--channel <channel>", "Inbox channel the ids belong to: email (default), linkedin, or whatsapp.")
+        .option("--yes", "Apply the action. Without this flag, returns a preview of the counts only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox bulk", options, () => {
+            // CLI uses hyphenated `set-status` for ergonomics; the API wants `set_status`.
+            const action = (readOption(options.action) ?? "").replace(/-/g, "_");
+            const channel = readOption(options.channel) ?? "email";
+            const status = readOption(options.status);
+            const ids = (readOption(options.ids) ?? "")
+                .split(",")
+                .map((id) => id.trim())
+                .filter(Boolean);
+            return requestOxygen("/api/cli/inbox/bulk", {
+                method: "POST",
+                previewOnly: !options.yes,
+                body: {
+                    action,
+                    channel,
+                    conversation_ids: ids,
+                    ...(status ? { status } : {}),
+                    ...(options.yes ? { approved: true } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("views")
+        .description("Saved Unibox views: named filter states the whole team shares (a sender, channels, statuses). Each member picks their own default, which the Unibox opens on.")
+        .addCommand(new Command("list")
+        .description("List the team's saved views; is_default marks your own default.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox views list", options, () => requestOxygen("/api/cli/inbox/views"));
+    }))
+        .addCommand(new Command("create")
+        .description("Save a view for the team.")
+        .requiredOption("--name <name>", "View name, unique in the workspace (up to 80 characters).")
+        .option("--filters <url-or-query>", "A Unibox URL or its query string, e.g. 'sender_profile_id=<id>&channels=linkedin&status=interested'. Keys are the `inbox list` filters (sender_profile_id is --sender-profile-id); a view without segment opens on the Primary tab, segment=all on every conversation. Omit for every conversation.")
+        .option("--default", "Also make it your own default view.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox views create", options, () => requestOxygen("/api/cli/inbox/views", {
+            method: "POST",
+            body: {
+                name: readOption(options.name),
+                ...(readOption(options.filters) ? { filters: readOption(options.filters) } : {}),
+                ...(options.default === true ? { default: true } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("update")
+        .description("Rename, re-filter or reorder a view, or set it as (or stop using it as) your own default.")
+        .argument("<view>", "View id (from `inbox views list`).")
+        .option("--name <name>", "New name.")
+        .option("--filters <url-or-query>", "Replace the view's filters: a Unibox URL or its query string (the `inbox list` filter keys; without segment the view opens on the Primary tab).")
+        .option("--position <n>", "Zero-based order in the team's list.")
+        .option("--default", "Make it your own default view.")
+        .option("--no-default", "Stop using it as your default view (you open on the built-in view).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (view, options) => {
+        await handleAsyncAction("inbox views update", options, () => requestOxygen(`/api/cli/inbox/views/${encodeURIComponent(view)}`, {
+            method: "PATCH",
+            body: {
+                ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+                ...(readOption(options.filters) !== null ? { filters: readOption(options.filters) } : {}),
+                ...(readOption(options.position) !== null ? { position: readNonNegativeInt(options.position) } : {}),
+                ...(typeof options.default === "boolean" ? { default: options.default } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("delete")
+        .description("Delete a view for the whole team. Anyone using it as their default opens on the built-in view.")
+        .argument("<view>", "View id (from `inbox views list`).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (view, options) => {
+        await handleAsyncAction("inbox views delete", options, () => requestOxygen(`/api/cli/inbox/views/${encodeURIComponent(view)}`, { method: "DELETE" }));
+    })))
+        .addCommand(new Command("labels")
+        .description("Manage inbox status labels (the Instantly-style system set + custom labels).")
+        .addCommand(new Command("list")
+        .description("List status labels.")
+        .option("--include-archived", "Include archived custom labels.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox labels list", options, () => requestOxygen(`/api/cli/inbox/labels${options.includeArchived ? "?include_archived=true" : ""}`));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a custom status label.")
+        .argument("<name>", "Display name.")
+        .option("--key <key>", "Stable custom status key; defaults to the name slug.")
+        .option("--icon <name>", "Label icon; an empty string clears it.")
+        .option("--sort-order <n>", "Numeric position; 0 is valid.")
+        .option("--color <hex>", "Hex color (e.g. #2a78d6). Workspace palette: #2a78d6 #eb6834 #1baf7a #eda100 #e87ba4 #008300 #4a3aa7 #e34948 #0e9dc4 #9a4fd0.")
+        .option("--bucket <bucket>", "primary (default) or others.")
+        .option("--ai-settable", "Let the AI reply classifier assign this label.")
+        .option("--description <text>", "What the label means / when it applies (used by the AI classifier).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (name, options) => {
+        await handleAsyncAction("inbox label create", options, () => {
+            const color = readOption(options.color);
+            const bucket = readOption(options.bucket);
+            const description = readOption(options.description);
+            return requestOxygen("/api/cli/inbox/labels", {
+                method: "POST",
+                body: {
+                    name,
+                    ...(color ? { color } : {}),
+                    ...(options.icon !== undefined ? { icon: options.icon } : {}),
+                    ...(options.sortOrder !== undefined ? { sort_order: Number(options.sortOrder) } : {}),
+                    ...(readOption(options.key) ? { key: readOption(options.key) } : {}),
+                    ...(bucket ? { bucket } : {}),
+                    ...(options.aiSettable ? { ai_settable: true } : {}),
+                    ...(description ? { description } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("update")
+        .description("Update a status label's name, color, bucket, description, or (custom labels only) ai-settable flag.")
+        .argument("<key>", "The label key.")
+        .option("--name <name>", "New display name.")
+        .option("--icon <name>", "Label icon; an empty string clears it.")
+        .option("--sort-order <n>", "Numeric position; 0 is valid.")
+        .option("--color <hex>", "New hex color.")
+        .option("--bucket <bucket>", "New bucket (primary or others).")
+        .option("--ai-settable", "Let the AI classifier assign this label (custom labels only).")
+        .option("--no-ai-settable", "Stop the AI classifier assigning this label (custom labels only).")
+        .option("--description <text>", "What the label means / when it applies (used by the AI classifier).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (key, options) => {
+        await handleAsyncAction("inbox label update", options, () => {
+            const name = readOption(options.name);
+            const color = readOption(options.color);
+            const bucket = readOption(options.bucket);
+            const description = readOption(options.description);
+            return requestOxygen(`/api/cli/inbox/labels/${encodeURIComponent(key)}`, {
+                method: "PATCH",
+                body: {
+                    ...(name ? { name } : {}),
+                    ...(color ? { color } : {}),
+                    ...(options.icon !== undefined ? { icon: options.icon } : {}),
+                    ...(options.sortOrder !== undefined ? { sort_order: Number(options.sortOrder) } : {}),
+                    ...(readOption(options.key) ? { key: readOption(options.key) } : {}),
+                    ...(bucket ? { bucket } : {}),
+                    ...(options.aiSettable !== undefined ? { ai_settable: options.aiSettable } : {}),
+                    ...(description ? { description } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("delete")
+        .description("Archive a custom status label (system labels and in-use labels are rejected).")
+        .argument("<key>", "The custom label key.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (key, options) => {
+        await handleAsyncAction("inbox label archive", options, () => requestOxygen(`/api/cli/inbox/labels/${encodeURIComponent(key)}`, { method: "DELETE" }));
+    }))
+        .addCommand(new Command("restore")
+        .description("Restore an archived custom status label under its original key.")
+        .argument("<key>", "The archived custom label key.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (key, options) => {
+        await handleAsyncAction("inbox label restore", options, () => requestOxygen(`/api/cli/inbox/labels/${encodeURIComponent(key)}`, {
+            method: "PATCH",
+            body: { archived: false },
+        }));
+    })))
+        .addCommand(new Command("drafts")
+        .description("The AI reply-agent draft queue (the approve-before-send review queue).")
+        .addCommand(addContractFlags(new Command("list")
+        .description("List drafts awaiting review (queued + edited by default), across email + LinkedIn.")
+        .option("--json", "Print a JSON envelope."), INBOX_DRAFTS_READ_CONTRACT, {
+        status: { valueName: "<keys>", help: "Comma-separated draft statuses (queued,edited,approved,sent,rejected).", parse: readOption },
+        channel: { valueName: "<channel>", help: "Filter to one channel: email or linkedin.", parse: readOption },
+        sequence_id: { valueName: "<id>", help: "Filter to one campaign (sequence) id (email drafts only).", parse: readOption },
+        limit: { valueName: "<n>", help: "Maximum drafts to return.", parse: readOption },
+        conversation_id: { valueName: "<id>", parse: readOption },
+        draft_id: { valueName: "<id>", parse: readOption },
+    })
+        .action(async (options) => {
+        await handleAsyncAction("inbox drafts list", options, () => {
+            const query = readContractFlags(options, INBOX_DRAFTS_READ_CONTRACT, {
+                status: { parse: readOption }, channel: { parse: readOption },
+                sequence_id: { parse: readOption }, limit: { parse: readOption },
+                conversation_id: { parse: readOption }, draft_id: { parse: readOption },
+            });
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined && value !== null)
+                    params.set(key, String(value));
+            }
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/inbox/drafts${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("edit")
+        .description("Edit an open draft's body before approval. Does not send.")
+        .argument("<draft>", "The draft id.")
+        .requiredOption("--text <message>", "The new draft body.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (draft, options) => {
+        await handleAsyncAction("inbox draft update", options, () => requestOxygen(`/api/cli/inbox/drafts/${encodeURIComponent(draft)}`, {
+            method: "PATCH",
+            body: { text: readOption(options.text) },
+        }));
+    }))
+        .addCommand(new Command("reject")
+        .description("Reject an open draft so it leaves the queue. Does not send.")
+        .argument("<draft>", "The draft id.")
+        .option("--reason <text>", "Optional reason.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (draft, options) => {
+        await handleAsyncAction("inbox draft reject", options, () => {
+            const reason = readOption(options.reason);
+            return requestOxygen(`/api/cli/inbox/drafts/${encodeURIComponent(draft)}/reject`, {
+                method: "POST",
+                body: reason ? { reason } : {},
+            });
+        });
+    })))
+        .addCommand(new Command("reply-agent")
+        .description("The draft-only AI reply agent (the 'AI Sales Agent'): auto-classifies + auto-drafts replies into the review queue. It NEVER auto-sends. Roster + run history: `oxygen agent get inbox-reply-drafts`; web home: /agents/inbox-reply-drafts.")
+        .addCommand(new Command("get")
+        .description("Show the reply-agent config.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox reply-agent get", options, () => requestOxygen("/api/cli/inbox/reply-agent"));
+    }))
+        .addCommand(new Command("set")
+        .description("Configure the reply agent (enable, persona/tone, targets). It drafts into the queue; a human approves+sends. Configuring is free (no credits); once enabled, each draft the agent writes consumes credits.")
+        .option("--enabled", "Enable the agent.")
+        .option("--disabled", "Disable the agent.")
+        .option("--persona <text>", "Who the agent writes as — drafts open in this voice. Richest results name role + company + what you sell, e.g. \"Jonas, founder of Acme (dev-tools for CI caching)\".")
+        .option("--tone <text>", "How drafts should read, e.g. \"warm, concise, low-pressure\".")
+        .option("--instructions <text>", "Extra drafting instructions.")
+        .option("--signature <text>", "Signature appended to drafts.")
+        .option("--target-statuses <keys>", "Comma-separated statuses to draft for (empty = all draftable).")
+        .option("--target-sequence-ids <ids>", "Comma-separated campaign ids to draft for (empty = all).")
+        .option("--channels <list>", "Comma-separated channels to draft for: a non-empty subset of email, linkedin (default email). LinkedIn drafts are short + signature-free.")
+        .option("--max-drafts-per-day <n>", "Per-day draft cap.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox reply-agent set", options, () => {
+            const body = {};
+            if (options.enabled)
+                body.enabled = true;
+            if (options.disabled)
+                body.enabled = false;
+            // Presence (flag passed) — not readOption — decides inclusion, so an
+            // absent flag leaves the field untouched rather than clearing it.
+            const opts = options;
+            for (const [flag, key] of [
+                ["persona", "persona"],
+                ["tone", "tone"],
+                ["instructions", "instructions"],
+                ["signature", "signature"],
+            ]) {
+                if (opts[flag] !== undefined)
+                    body[key] = opts[flag];
+            }
+            if (options.targetStatuses !== undefined) {
+                body.target_statuses = options.targetStatuses.split(",").map((s) => s.trim()).filter(Boolean);
+            }
+            if (options.targetSequenceIds !== undefined) {
+                body.target_sequence_ids = options.targetSequenceIds.split(",").map((s) => s.trim()).filter(Boolean);
+            }
+            if (options.channels !== undefined) {
+                body.channels = options.channels.split(",").map((c) => c.trim()).filter(Boolean);
+            }
+            if (options.maxDraftsPerDay !== undefined)
+                body.max_drafts_per_day = Number(options.maxDraftsPerDay);
+            return requestOxygen("/api/cli/inbox/reply-agent", { method: "POST", body });
+        });
+    })))
+        .addCommand(new Command("auto-tagger")
+        .description("The auto-tagging agent (the 'AI Inbox Tagger'): classifies each new inbound conversation against your workspace tag allowlist and auto-applies matches — additive, never re-adds a tag you removed, zero extra model calls (rides the analysis pass). Roster + run history: `oxygen agent get inbox-auto-tagger`; web home: /agents/inbox-auto-tagger.")
+        .addCommand(new Command("get")
+        .description("Show the auto-tagger config (enabled, tag allowlist, channels).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox auto-tagger get", options, () => requestOxygen("/api/cli/inbox/auto-tagger"));
+    }))
+        .addCommand(new Command("set")
+        .description("Update the auto-tagger. --tags replaces the whole allowlist (max 50; `--tags \"\"` clears, which pauses tagging while keeping the agent enabled).")
+        .option("--enabled", "Enable the agent.")
+        .option("--disabled", "Disable the agent.")
+        .option("--tags <tags>", "Comma-separated tag allowlist the classifier may apply (replaces the whole set).")
+        .option("--channels <list>", "Comma-separated channels to tag: a non-empty subset of email, linkedin, whatsapp (default all three).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox auto-tagger set", options, () => {
+            const body = {};
+            if (options.enabled)
+                body.enabled = true;
+            if (options.disabled)
+                body.enabled = false;
+            if (options.tags !== undefined) {
+                body.tags = options.tags.split(",").map((tag) => tag.trim()).filter(Boolean);
+            }
+            if (options.channels !== undefined) {
+                body.channels = options.channels.split(",").map((c) => c.trim()).filter(Boolean);
+            }
+            return requestOxygen("/api/cli/inbox/auto-tagger", { method: "POST", body });
+        });
+    }))));
+}