@oxygen-agent/cli 1.1014.1600 → 1.1014.1763

package/dist/commands/mailboxes.js

@@ -553,15 +553,23 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
     }))
         .addCommand(new Command("health")
         .description("Fleet email-health: the sending pool rolled up by external deliverability reputation (healthy/degraded/critical/unknown), per-mailbox scores, connected health providers, and DIRECTIONAL recommendations — plus OXYGEN's OWN evidence for the last 7 days, which needs no provider connected: the bounce notifications each mailbox received classified as provider rejection / dead address / mailbox full / delay (a Google receiving-server policy rejection shows up as provider_rejected), distinct recipients with a hard bounce in the window (legacy facts retain their first observation time), sequence sends OXYGEN logged (source=sequence only), warm-up day, health score and stop cause, each mailbox's configured daily cap, and the same rollup per sending domain ranked worst-first. Notifications whose body was never stored count as signals.dsn7d.unclassified, which means OXYGEN could not look — not that nothing was wrong. Read health_coverage to see how many mailboxes an external provider has actually scored. Start from the fleet read instead of scanning the mailbox array: warmup.byCause (why warm-up stopped, counted once for the whole pool). Per-mailbox warmup.state and fleet warmup.byState are stored rail telemetry; use `oxygen mailboxes list --json` warmupTruth for enrollment state and next actions. The rolling window is signals.window (7d). Delivery notifications include all send sources, including warm-up and manual mail; signals.sendSource=sequence restricts only coldSends7d. Identified warm-up rejections are reported separately, and other notifications have no verified send-source attribution. Rejections alone do not establish that prospect mail was rejected or that a whole domain is blocked. A zero means no such evidence was recorded in the stated window, not that the fleet is un-blocklisted everywhere. Pure read — 0 credits; never pauses a mailbox or changes a cap.")
-        .addOption(new Option("--view <view>", "Summary: complete compact roster (default); fleet: domain, DSN and warm-up totals without rows; full: all inbox evidence.").choices(["summary", "fleet", "full"]))
+        .addOption(new Option("--view <view>", "Start with --view fleet for totals; summary: complete compact roster (default); full: per-inbox evidence.").choices(["summary", "fleet", "full"]))
+        .option("--mailboxes <list>", "Inspect 1–100 mailbox ids or addresses, comma-separated (defaults to full evidence). Fleet totals remain unfiltered.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleReadActionWithLens("mailboxes health", options, () => requestOxygen(`/api/cli/mailboxes/health?view=${encodeURIComponent(options.view ?? "summary")}`), formatMailboxFleetHealth);
+        const query = new URLSearchParams({ view: options.view ?? (options.mailboxes !== undefined ? "full" : "summary") });
+        if (options.mailboxes !== undefined)
+            query.set("mailboxes", options.mailboxes);
+        await handleReadActionWithLens("mailboxes health", options, () => requestOxygen(`/api/cli/mailboxes/health?${query}`), formatMailboxFleetHealth);
     }))
         .addCommand(new Command("compatibility")
-        .description("Read-only compatibility report per mailbox — select with --mailboxes <address,…> (omit for the whole pool; filter here, not in a script): generic origin class, real infrastructure tier (including InboxKit Azure), OXYGEN native-send connection quality, OXYGEN Warm-up path, OXYGEN deliverability monitoring path, and exact next actions. Read automatic_repair for native send and warmup_automatic_repair for an existing warm-up seat: mode=automatic means OXYGEN owns the next bounded retry. Native send distinguishes destination-bound OAuth, provider-managed API transport, admin delegation, and authorization_required. Use --catalog-only for the compact workspace-independent import contract. JSON data.compatibility contains checked rows; data.import_methods and data.import_fields describe accepted transfer inputs; data.provider_matrix is the current public product matrix; data.non_transferable_auth names credentials that must be reconnected; data.summary rolls up states; data.web_url opens the pool. Downstream states distinguish credential_required, consent_required, and vendor_blocked. Never decrypts a credential or calls a downstream provider.")
+        .description("Read-only compatibility report per mailbox — select with --mailboxes <address,…> (omit for the whole pool; filter here, not in a script): generic origin class, real infrastructure tier (including InboxKit Azure), OXYGEN native-send connection quality, OXYGEN Warm-up path, OXYGEN deliverability monitoring path, and exact next actions. Read automatic_repair for native send and warmup_automatic_repair for an existing warm-up seat: mode=automatic means OXYGEN owns the next bounded retry. Native send distinguishes destination-bound OAuth, provider-managed API transport, admin delegation, and authorization_required. Use --catalog-only for the compact workspace-independent import contract. JSON data.compatibility contains checked rows; data.import_methods and data.import_fields describe accepted transfer inputs; data.provider_matrix is the current public product matrix; data.non_transferable_auth names credentials that must be reconnected; data.summary rolls up states; data.web_url opens the pool. Downstream states distinguish credential_required, consent_required, and vendor_blocked. Never decrypts credentials or writes provider state. The full report may read InboxKit source-warmup status; --remedy oauth uses stored authorization only with no provider calls and leaves warm-up and deliverability unchecked.")
         .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses. Omit for the whole pool.")
         .option("--catalog-only", "Return only the bounded import-method, field, auth-boundary, and public provider catalogs; do not read or return workspace mailbox rows.")
+        .option("--vendor <origin>", "Filter the canonical mailbox origin, for example inboxkit, zapmail or native.")
+        .option("--provider <provider>", "Filter google or microsoft.")
+        .option("--remedy <remedy>", "Filter a native-send remedy code; oauth reports stored authorization only without provider calls.")
+        .option("--summary-only", "Return counts without individual mailbox rows.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("mailboxes compatibility", options, () => {
@@ -576,6 +584,13 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
             if (mailboxes.length > 0) {
                 params.set("mailboxes", mailboxes.join(","));
             }
+            for (const key of ["vendor", "provider", "remedy"]) {
+                const value = readOption(options[key]);
+                if (value)
+                    params.set(key, value);
+            }
+            if (options.summaryOnly)
+                params.set("summary_only", "true");
             const suffix = params.toString();
             return requestOxygen(`/api/cli/mailboxes/compatibility${suffix ? `?${suffix}` : ""}`);
         });
@@ -781,12 +796,13 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
         });
     })))
         .addCommand(new Command("update")
-        .description("Update a sending mailbox's rich-content profile: the From display name and/or the HTML signature appended to its sends. An email that already contains the signature gets no second copy. Pass an empty string ('') to clear a field. Consumes no Oxygen credits. <mailbox> accepts a mailbox id or email address.")
+        .description("Update a sending mailbox's rich-content profile: the From display name and/or the HTML signature appended to its sends. An email that already contains the signature gets no second copy. Pass an empty string ('') to clear a field. Also sets its bounce protection and which inbound mail AI reply classification triages (--classify). Consumes no Oxygen credits. <mailbox> accepts a mailbox id or email address.")
         .argument("<mailbox>", "Mailbox id or email address.")
         .option("--display-name <name>", "From display name (e.g. \"Ada from Acme\"). Pass '' to clear it.")
         .option("--signature-html <html>", "HTML signature appended to every send from this mailbox. Pass '' to clear it.")
         .option("--signature-file <path>", "Read the HTML signature from a file instead of --signature-html.")
         .option("--bounce-protection <json>", "Mailbox bounce policy (partial updates merge): enabled=true, warning_rate=.02, pause_rate=.03, min_sends=20, window_days=7. Hard bounces / accepted sends in the rolling window; pauses this mailbox. Rates are fractions; sequence protection is separate.")
+        .option("--classify <scope>", "Which inbound conversations AI reply classification triages (each one uses credits): replies (Sequence threads and threads you wrote in; other mail, such as newsletters and notifications, stays in Unibox unclassified at no cost) or all (every inbound conversation). Default: replies for a Google mailbox you added yourself, all for every other mailbox. Applies to new mail; `mailboxes get` shows the current scope.")
         .option("--json", "Print a JSON envelope.")
         .action(async (mailbox, options) => {
         await handleAsyncAction("mailboxes update", options, () => {
@@ -795,6 +811,8 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
             const patch = {};
             if (options.bounceProtection !== undefined)
                 patch.bounce_protection = JSON.parse(options.bounceProtection);
+            if (options.classify !== undefined)
+                patch.classification_scope = options.classify;
             if (options.displayName !== undefined)
                 patch.display_name = options.displayName;
             if (options.signatureHtml !== undefined) {
@@ -804,7 +822,7 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
                 patch.signature_html = readFileSync(resolve(options.signatureFile), "utf8");
             }
             if (Object.keys(patch).length === 0) {
-                throw new Error("Provide --display-name and/or --signature-html (or --signature-file).");
+                throw new Error("Provide --display-name, --signature-html (or --signature-file), --bounce-protection or --classify.");
             }
             return requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}`, {
                 method: "PATCH",
@@ -836,8 +854,9 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
         .option("--no-canary", "inboxkit only: fan out to every eligible mailbox on a domain that has never connected one, instead of firing a single canary first.")
         .option("--connection <id>", "Zapmail connection id. Defaults to the org's active Zapmail connection.")
         .option("--status <id>", "Poll a previously started Zapmail, InboxKit, or OXYGEN direct-consent run.")
-        .option("--dry-run", "Preview the requested mailbox/domain scope and external writes without changing vendor or ledger state. This is the default for starts; a successful preview can still have zero eligible mailboxes, so check InboxKit candidates with oauth-health before approval.")
+        .option("--dry-run", "Preview the requested mailbox/domain scope and external writes without changing vendor or ledger state. InboxKit enumerates consent candidates, skipped reasons, domain approvals and exact external writes; approve its fresh plan hash. This is the default for starts.")
         .option("--approved", "Start the reviewed authorization run. Composio creates an individual consent link for each owner, who must open it and approve access with Google or Microsoft. Native vendor=oxygen records expiring browser steps for the selected owner or tenant administrator. Starting a run does not grant mail access.")
+        .option("--plan-hash <hash>", "InboxKit: exact fresh eligibility/approval preview hash; required with --approved.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("mailboxes connect-oauth", options, () => {
@@ -867,6 +886,7 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
                 method: "POST",
                 body: {
                     provider,
+                    ...(readOption(options.planHash) ? { plan_hash: readOption(options.planHash) } : {}),
                     ...(options.googleSmtp === true ? { google_smtp: true } : {}),
                     // Every key stays absent unless it was asked for, so a run
                     // without the new flags is the request this command has always

package/dist/commands/managed-inboxes.js

@@ -126,8 +126,8 @@ export function registerManagedInboxesFamily(program, handleAsyncAction) {
         .addOption(new Option("--preview", "Explicit read-only quote: connects nothing, buys nothing and charges nothing. Cannot be combined with purchase or DNS cleanup approval.").conflicts(["approved", "dnsCleanupApproved"]))
         .option("--existing-domain", "Use an existing Cloudflare domain from oxygen domains list; never register or transfer it.")
         .option("--max-per-domain <n>", "Save a stricter mailbox limit with the approved order, including existing addresses (e.g. 2). Preview does not save it.")
-        .option("--dns-cleanup-records <ids>", "Preview deletion of these comma-separated exact email DNS record IDs on an existing domain; connects and buys nothing.")
-        .addOption(new Option("--dns-cleanup-approved", "Delete only the reviewed email records; requires --dns-cleanup-records and --dns-cleanup-hash. Request a fresh purchase quote afterward.").conflicts("approved"))
+        .option("--dns-cleanup-records <ids>", "Optional standalone cleanup: preview deletion of these comma-separated email DNS record IDs; buys nothing. An approved existing-domain order already removes the records its preview lists.")
+        .addOption(new Option("--dns-cleanup-approved", "Delete only the reviewed email records without buying; requires --dns-cleanup-records and --dns-cleanup-hash. Request a fresh purchase quote afterward.").conflicts("approved"))
         .option("--dns-cleanup-hash <hash>", "The plan_hash from the exact DNS cleanup preview, required to delete records.")
         .option("--years <n>", "Years to register a new domain for (1-10). Omit for existing domains.")
         .option("--redirect-url <url>", "Where the domain's web root redirects. Defaults to your workspace's company website; editable later with `oxygen domains forwarding set`.")

package/dist/commands/senders.js

@@ -203,15 +203,15 @@ export function registerSendersFamily(program, handleAsyncAction) {
         .description("Show current limits, overrides, working hours (timezone, days, start, end), defaults, hard maximums, and the caution levels above which LinkedIn restriction risk rises, for an account. <id> accepts a sender account id, connection id, or Unipile account id.")
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
-        .action(async (id, options) => {
-        await handleAsyncAction("senders limits get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
+        .action(async (id, options, command) => {
+        await handleAsyncAction("senders limits get", { ...options, json: command.optsWithGlobals().json === true }, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
     }))
         .addCommand(addContractFlags(new Command(SENDER_LIMITS_SET_OPERATION.cli.path.at(-1) ?? "set")
         .description(SENDER_LIMITS_SET_OPERATION.cli.summary)
         .argument("<id>", SENDER_LIMITS_SET_OPERATION.cli.argument?.description), SENDER_LIMITS_SET_OPERATION.contract, SENDER_LIMITS_FLAG_OVERLAY)
         .option("--json", "Print a JSON envelope.")
-        .action(async (id, options) => {
-        await handleAsyncAction("senders limits set", options, () => {
+        .action(async (id, options, command) => {
+        await handleAsyncAction("senders limits set", { ...options, json: command.optsWithGlobals().json === true }, () => {
             const body = buildSenderLimitsBody(options);
             return requestOxygen(operationPath(SENDER_LIMITS_SET_OPERATION, { id }), {
                 method: SENDER_LIMITS_SET_OPERATION.method,

package/dist/commands/sequences.js

@@ -3,7 +3,12 @@ import { parseJsonObject, readNonNegativeInt, readPositiveInt } from "../cli-val
 import { ansi, collectRepeatable, handleReadActionWithLens, parseJsonValue, readCreditCeilingOrZero, readCsvOption, readJsonFileValue, readPositiveNumber, readPublishingPostText, renderTextTable, splitCommaList } from "../command-support.js";
 import { addContractFlags, readContractFlags } from "../contract-flags.js";
 import { requestOxygen } from "../http-client.js";
+import { sequencesBrandKitCommand } from "../sequences-brand-kit-command.js";
+import { sequencesContentCommand } from "../sequences-content-commands.js";
+import { formatNewsletterStatsLines, readNewsletterIntervalFlag, sequencesRecipientsCommand } from "../sequences-newsletter-commands.js";
+import { sequencesTestSendCommand } from "../sequences-test-send-command.js";
 import { networkMiningHostServed } from "../network-mining-host.js";
+import { parseStartAtFlag } from "../sequence-start-at.js";
 import { parseWorkingDaysOption } from "../sender-limits-flags.js";
 import { isRecord, readOption } from "../util.js";
 import { OxygenError, success } from "@oxygen/shared/cli-result";
@@ -576,6 +581,10 @@ function formatSequenceChannelFunnels(funnels, replies) {
     const channels = ["linkedin", "email", "whatsapp"].filter((channel) => isRecord(byChannel[channel]));
     if (channels.length === 0)
         return [];
+    // OXYGEN offers no open tracking, so on such a deployment every channel's
+    // opens are not_supported and the column would read n/a on every row (Tim,
+    // 2026-10-22: hide it). It stays while any channel can report opens.
+    const showOpened = channels.some((channel) => stringValue(recordValue(recordValue(recordValue(byChannel[channel]).coverage).opened).state) !== "not_supported");
     const rows = channels.map((channel) => {
         const funnel = recordValue(byChannel[channel]);
         const invites = recordValue(funnel.invites);
@@ -585,13 +594,13 @@ function formatSequenceChannelFunnels(funnels, replies) {
             numberText(funnel.sends),
             numericValue(invites.sent) === null ? "n/a" : `${numberText(invites.accepted)}/${numberText(invites.sent)}`,
             funnelMetricText(funnel, "delivered"),
-            funnelMetricText(funnel, "opened"),
+            ...(showOpened ? [funnelMetricText(funnel, "opened")] : []),
             funnelMetricText(funnel, "replied"),
             funnelRateText(funnel, "replyRate", "replied"),
             funnelMetricText(funnel, "positiveReplied"),
         ];
     });
-    const lines = ["", ...renderTextTable(["CHANNEL", "PEOPLE", "SENDS", "ACCEPTED", "DELIVERED", "OPENED", "REPLIED", "REPLY RATE", "POSITIVE"], rows)];
+    const lines = ["", ...renderTextTable(["CHANNEL", "PEOPLE", "SENDS", "ACCEPTED", "DELIVERED", ...(showOpened ? ["OPENED"] : []), "REPLIED", "REPLY RATE", "POSITIVE"], rows)];
     // Name the remedy once per distinct gap rather than once per row.
     const remedies = new Map();
     for (const channel of channels) {
@@ -688,6 +697,7 @@ function formatSequenceStatsHealth(data) {
             ["Replies", numberText(stats.totalReplies ?? stats.replied)],
         ]));
     }
+    lines.push(...formatNewsletterStatsLines(data.newsletter));
     const link = stringValue(data.web_url) ?? stringValue(data.deepLink);
     if (link)
         lines.push("", link);
@@ -760,7 +770,12 @@ function operationalStateText(sequence, operational) {
     if (!state)
         return null;
     // The server's own `lifecycle`; the shared helper covers a server that predates it.
-    const lifecycle = stringValue(sequence.lifecycle) ?? sequenceDisplayStatus(stringValue(sequence.status) ?? "", state);
+    const settings = isRecord(sequence.settings) ? sequence.settings : null;
+    const lifecycle = stringValue(sequence.lifecycle) ?? sequenceDisplayStatus(stringValue(sequence.status) ?? "", state, settings);
+    if (lifecycle === "scheduled") {
+        const startAt = stringValue(settings?.start_at);
+        return `${state} (scheduled${startAt ? ` for ${startAt}` : ""})`;
+    }
     return lifecycle === "completed" ? `${state} (completed)` : state;
 }
 /** A listed Sequence's launch warnings (e.g. two sending schedules), one line each. */
@@ -1342,7 +1357,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .description("List sequences with persisted launch status kept separate from current operational state. Fleet counts report marked-active versus operationally-live (active with nonterminal work), and rows explain flowing, paced, paused, blocked, degraded, drained, or empty work without SQL. An active sequence whose every lead has finished shows drained (completed); leads enrolled into it later are contacted on its next dispatch tick. --stats joins each row's LIFETIME funnel.")
         .option("--status <status>", "Filter by status: draft, active, paused, or archived.")
         .addOption(new Option("--operational-state <state>", "Filter by current work state; fleet counts remain unfiltered: empty, drained, never_started (enrolled leads, never launched), blocked, degraded, flowing, paced, or paused (work waiting on a paused sequence).").choices(["empty", "drained", "never_started", "blocked", "degraded", "flowing", "paced", "paused"]))
-        .addOption(new Option("--lifecycle <lifecycle>", "Filter by the lifecycle a person reads; fleet counts remain unfiltered: draft, active, completed (active, every lead finished), paused, or archived.").choices([...SEQUENCE_LIFECYCLES]))
+        .addOption(new Option("--lifecycle <lifecycle>", "Filter by the lifecycle a person reads; fleet counts remain unfiltered: draft, scheduled (active, start_at still ahead), active, completed (active, every lead finished), paused, or archived.").choices([...SEQUENCE_LIFECYCLES]))
         .addOption(new Option("--channel <channel>", "Only sequences carrying this channel.").choices(["email", "linkedin", "whatsapp"]))
         .option("--tag <tag>", "Only sequences carrying this workspace tag (see `oxygen tags list`).")
         .option("--stats", "Attach lifetime stats per sequence (a stats pass per row — slower on large workspaces)."), SEQUENCE_LIST_PROJECTION_CONTRACT)
@@ -1672,8 +1687,8 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .option("--bounce-protection <json>", "Sequence bounce policy JSON (partial updates merge): enabled=true, warning_rate=.02, pause_rate=.03, min_sends=20, window_days=7. Hard bounces / accepted sends in the rolling window; pauses this sequence, not the fleet. Rates are fractions; mailbox protection is separate.")
         .option("--auto-optimize", "Enable the sequence-wide A/B auto-winner (default on).")
         .option("--no-auto-optimize", "Disable the sequence-wide A/B auto-winner; manual variant decisions stay available.")
-        .option("--reply-to-stop-text <text>", "Optional first-touch email footer (max 500 characters); empty clears.")
-        .option("--include-unsubscribe", "Add an unsubscribe option to emails, the same as the Sending settings switch: a visible recipient-bound link (plain text shows the URL, HTML a linked Unsubscribe label) plus one-click headers that mail apps show as an Unsubscribe button, both on first-touch cold emails; in-thread follow-ups carry neither. Zapbox sends (mailboxes imported from Zapmail, `transport: \"zapbox\"` in `mailboxes list --json`) carry the link only. Off by default. Use --reply-to-stop-text for an optional first-touch email footer. `sequences update` can switch on the link or the headers alone.")
+        .option("--reply-to-stop-text <text>", "Optional first-touch email footer (max 500 characters); with the unsubscribe option on, plain-text emails show it in place of the link. Empty clears.")
+        .option("--include-unsubscribe", "Add an unsubscribe option to emails, the same as the Sending settings switch: a visible opt-out (HTML a linked Unsubscribe label; plain text the --reply-to-stop-text line, else a default opt-out line, never the URL) plus one-click headers that mail apps show as an Unsubscribe button, both on first-touch cold emails; in-thread follow-ups carry neither. Zapbox sends (mailboxes imported from Zapmail, `transport: \"zapbox\"` in `mailboxes list --json`) carry the link only. Off by default. Use --reply-to-stop-text for an optional first-touch email footer. `sequences update` can switch on the link or the headers alone.")
         .option("--no-include-unsubscribe", "Turn off both the visible unsubscribe link and the one-click headers.")
         .option("--tracking-opens", "Opt in to open tracking (default off). Requires a verified tracking domain and deployment tracking secret.")
         .option("--no-tracking-opens", "Turn OFF the open pixel for this sequence's native email sends (a deliverability knob — a pixel is spam-filter surface).")
@@ -1822,12 +1837,12 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .option("--bounce-protection <json>", "Sequence bounce policy JSON (partial updates merge): enabled=true, warning_rate=.02, pause_rate=.03, min_sends=20, window_days=7. Hard bounces / accepted sends in the rolling window; pauses this sequence, not the fleet. Rates are fractions; mailbox protection is separate.")
         .option("--auto-optimize", "Turn the A/B auto-winner on (the default): every step with variants is judged on replies, pausing losers once each variant has 100 sends and 5 replies, unless the step sets its own auto_optimize.")
         .option("--no-auto-optimize", "Disable the sequence-wide A/B auto-winner; manual variant decisions stay available.")
-        .option("--reply-to-stop-text <text>", "Optional first-touch email footer (max 500 characters); empty clears.")
-        .option("--include-unsubscribe", "Add an unsubscribe option to emails, the same as the Sending settings switch: a visible recipient-bound link (plain text shows the URL, HTML a linked Unsubscribe label) plus one-click headers that mail apps show as an Unsubscribe button, both on first-touch cold emails; in-thread follow-ups carry neither. Zapbox sends (mailboxes imported from Zapmail, `transport: \"zapbox\"` in `mailboxes list --json`) carry the link only. Off by default. Use --reply-to-stop-text for an optional first-touch email footer.")
+        .option("--reply-to-stop-text <text>", "Optional first-touch email footer (max 500 characters); with the unsubscribe option on, plain-text emails show it in place of the link. Empty clears.")
+        .option("--include-unsubscribe", "Add an unsubscribe option to emails, the same as the Sending settings switch: a visible opt-out (HTML a linked Unsubscribe label; plain text the --reply-to-stop-text line, else a default opt-out line, never the URL) plus one-click headers that mail apps show as an Unsubscribe button, both on first-touch cold emails; in-thread follow-ups carry neither. Zapbox sends (mailboxes imported from Zapmail, `transport: \"zapbox\"` in `mailboxes list --json`) carry the link only. Off by default. Use --reply-to-stop-text for an optional first-touch email footer.")
         .option("--no-include-unsubscribe", "Turn off both the visible unsubscribe link and the one-click headers.")
         .option("--include-unsubscribe-headers", "Only the one-click unsubscribe headers (default off); --include-unsubscribe turns on the headers and the visible link together.")
         .option("--no-include-unsubscribe-headers", "Omit one-click headers.")
-        .option("--include-unsubscribe-link", "Only the visible recipient-bound unsubscribe footer on first-touch cold emails (default off; --include-unsubscribe adds the one-click headers too). Plain-text messages show the URL, while HTML messages show a linked Unsubscribe label.")
+        .option("--include-unsubscribe-link", "Only the visible recipient-bound unsubscribe footer on first-touch cold emails (default off; --include-unsubscribe adds the one-click headers too). HTML messages show a linked Unsubscribe label; plain-text messages show the --reply-to-stop-text line, else a default opt-out line, instead of the URL.")
         .option("--no-include-unsubscribe-link", "Turn the visible unsubscribe footer OFF. Future first-touch emails send the authored body unchanged; existing suppression records remain enforced.")
         .option("--tracking-opens", "Opt in to open tracking (default off). Requires a verified tracking domain and deployment tracking secret.")
         .option("--no-tracking-opens", "Turn OFF the open pixel for this sequence's native email sends (a deliverability knob — a pixel is spam-filter surface).")
@@ -2038,6 +2053,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .option("--max-live-sends <n>", "Total live-send and CRM-write ceiling across channels, including LinkedIn invites/messages (positive integer). Required for email, WhatsApp, or crm_task steps; guided LinkedIn binds its positive cap in launch_review.")
         .option("--launch-review-json <json>", "Guided onboarding: echo the exact preview.launch_review (digest, expiry, positive action ceiling and nonnegative credit cap). Changed inputs require a new preview.")
         .option("--launch-review-file <path>", "Read the exact launch_review object from a JSON file instead of --launch-review-json.")
+        .option("--at <time>", "Schedule a draft's start: an ISO timestamp with a timezone (2026-11-02T09:00:00Z) or \"in 30m\" / \"in 2h\" / \"in 3d\", at most 30 days ahead. With --approved it activates now and sends nothing before then (lifecycle scheduled); cancel with `sequences unschedule`.")
         .option("--dry-run", "Activate the sequence (status draft → active, startedAt set) in dry-run mode: every step advances with simulated actions — no sends, CRM writes, provider calls, or credits. This is NOT the preview: `sequences start` with no flags is the side-effect-free launch preview. A later live start (--approved) restarts those leads from the first step so they are contacted for real, except deleted source rows, a person another live campaign contacts under exclude_contacted, and older duplicates of a person.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
@@ -2051,6 +2067,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
                 : options.launchReviewJson !== undefined ? parseJsonObject(options.launchReviewJson) : undefined;
             if (launchReview !== undefined && !isRecord(launchReview))
                 throw new OxygenError("invalid_request", "The launch review must be the exact object returned by the preview.", { exitCode: 2 });
+            const startAt = options.at === undefined ? undefined : parseStartAtFlag(options.at);
             return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/start`, {
                 method: "POST",
                 body: {
@@ -2059,6 +2076,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
                     ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
                     ...(maxLiveSends !== undefined ? { max_live_sends: maxLiveSends } : {}),
                     ...(launchReview !== undefined ? { launch_review: launchReview } : {}),
+                    ...(startAt !== undefined ? { start_at: startAt } : {}),
                 },
             });
         });
@@ -2147,6 +2165,15 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         await handleAsyncAction("sequences pause", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/status`, {
             method: "POST", body: { status: "paused" },
         }));
+    }))
+        .addCommand(new Command("unschedule")
+        .description("Cancel a scheduled start (`sequences start --at`) before it comes: the Sequence returns to draft, its leads to pending, and the start time is cleared. Refused once the start has come or anything was planned; pause it then. Repeating it changes nothing.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleAsyncAction("sequences unschedule", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/unschedule`, {
+            method: "POST", body: {},
+        }));
     }))
         .addCommand(new Command("resume")
         .description("Resume a paused sequence. A campaign paused at its live send cap pauses again at once: raise the cap and resume in one step with `sequences start <sequence> --max-live-sends <n>` (preview, then --approved).")
@@ -2440,12 +2467,17 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         });
     }))
         .addCommand(new Command("stats")
-        .description("Show one sequence's persisted launch status and current operational state separately, including reasons, open work, lifetime sent/terminal-failed/deferral counts, and the funnel. Today's completed sends, reservations and remaining capacity appear in the default output and daily_budget. operational.reasons carries why work is waiting (outside_send_window, mailbox_spacing, daily_send_cap_reached, ...). For a per-day send series use `sequences analytics --sequence <id> --range <window>`.")
+        .description("Show one sequence's persisted launch status and current operational state separately, including reasons, open work, lifetime sent/terminal-failed/deferral counts, and the funnel. Today's completed sends, reservations and remaining capacity appear in the default output and daily_budget. operational.reasons carries why work is waiting (outside_send_window, mailbox_spacing, daily_send_cap_reached, ...). For a per-day send series use `sequences analytics --sequence <id> --range <window>`. A newsletter (sending-domain Sequence) adds a newsletter block: delivered, estimated opens, clicks per link, bounces, complaints, unsubscribes and a first-week timeline; per-recipient status is `sequences recipients`.")
         .argument("<sequence>", "Sequence id or slug.")
+        .option("--interval <hour|day>", "Newsletter timeline buckets over the first 7 days (default day).")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleReadActionWithLens("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`), formatSequenceStatsHealth);
+        await handleReadActionWithLens("sequences stats", options, () => {
+            const interval = readNewsletterIntervalFlag(options.interval);
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats${interval ? `?interval=${interval}` : ""}`);
+        }, formatSequenceStatsHealth);
     }))
+        .addCommand(sequencesRecipientsCommand())
         .addCommand(new Command("esp")
         .description("ESP breakdown of this sequence's email sending scope: which provider each enrolled lead's mail routes through (google/microsoft, plus named gateways like Proofpoint/Mimecast and non-matchable hosts), folded against your sending mailbox pool. Shows how many leads the CURRENT --esp-matching mode would defer before you turn it on. Resolves domains from MX + SPF (0 credits, DNS only) and caches the result, warming the send path. Preview before flipping strict/prefer.")
         .argument("<sequence>", "Sequence id or slug.")
@@ -2480,5 +2512,8 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
         await handleSequenceVariantsAction(sequence, options);
-    })));
+    }))
+        .addCommand(sequencesContentCommand(handleAsyncAction))
+        .addCommand(sequencesBrandKitCommand(handleAsyncAction))
+        .addCommand(sequencesTestSendCommand(handleAsyncAction)));
 }

package/dist/commands/subscriptions.d.ts

@@ -1,9 +1,7 @@
 import { ExtractedCommandActionHandler } from "../command-support.js";
+import { type EmailContactImportRow } from "@oxygen/shared/email-subscriptions";
 import { Command } from "commander";
-type ImportEntry = {
-    email: string;
-    person_id?: string;
-};
+type ImportEntry = EmailContactImportRow;
 /** Read --file as JSON (by extension or content) or as CSV with an email column. */
 export declare function readSubscriptionImportFile(path: string): ImportEntry[];
 export declare function registerSubscriptionsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;