@oxygen-agent/cli 1.1014.1465 → 1.1014.1598

package/dist/commands/sequences.js

@@ -1180,8 +1180,44 @@ function readDailyCapOption(value, flag) {
     }
     return parsed;
 }
+/**
+ * settings.email_delivery from `--delivery` and the sending-domain flags, the
+ * same object the web Sending settings control saves. A sending-domain flag
+ * alone means sending-domain delivery; on update the server keeps the stored
+ * fields a flag does not name. `--delivery inboxes` clears the shape; `""`
+ * clears --from-name and --reply-to-mailbox.
+ */
+function readEmailDeliveryOptions(options) {
+    const fields = {};
+    if (options.sendingDomain !== undefined)
+        fields.sending_domain_id = options.sendingDomain.trim();
+    if (options.fromAddress !== undefined)
+        fields.from_address = options.fromAddress.trim();
+    if (options.fromName !== undefined)
+        fields.from_name = options.fromName.trim();
+    if (options.replyToMailbox !== undefined)
+        fields.reply_to_mailbox_id = options.replyToMailbox.trim() || null;
+    if (options.subscriptionList !== undefined)
+        fields.subscription_list_id = options.subscriptionList.trim();
+    const mode = options.delivery?.trim().toLowerCase().replace(/-/g, "_");
+    if (mode === "inboxes") {
+        if (Object.keys(fields).length > 0) {
+            throw new OxygenError("invalid_input", "--delivery inboxes takes no --sending-domain, --from-address, --from-name, --reply-to-mailbox or --subscription-list.", { exitCode: 2 });
+        }
+        return { mode: "inboxes" };
+    }
+    if (mode !== undefined && mode !== "sending_domain") {
+        throw new OxygenError("invalid_input", "--delivery must be inboxes or sending-domain.", { exitCode: 2 });
+    }
+    if (mode === undefined && Object.keys(fields).length === 0)
+        return undefined;
+    return { mode: "sending_domain", ...fields };
+}
 function readSequenceSettings(options) {
     const settings = {};
+    const emailDelivery = readEmailDeliveryOptions(options);
+    if (emailDelivery)
+        settings.email_delivery = emailDelivery;
     // 0 is a real cap, as on the web's Sending limits (0-50).
     const maxPerMailbox = readNonNegativeInt(options.maxEmailsPerMailboxPerDay);
     if (maxPerMailbox !== undefined) {
@@ -1237,6 +1273,8 @@ function readSequenceSettings(options) {
         settings.bounce_protection = JSON.parse(options.bounceProtection);
     if (options.includeUnsubscribeHeaders !== undefined)
         settings.include_unsubscribe_headers = options.includeUnsubscribeHeaders;
+    if (options.replyToStopText !== undefined)
+        settings.reply_to_stop_text = options.replyToStopText;
     if (options.includeUnsubscribeLink !== undefined) {
         settings.include_unsubscribe_link = options.includeUnsubscribeLink;
     }
@@ -1333,6 +1371,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
             const omit = typeof projection.omit === "string" ? readOption(projection.omit) : undefined;
             if (omit)
                 params.set("omit", omit);
+            params.set("view", typeof projection.view === "string" ? projection.view : "summary");
             const suffix = params.toString();
             return requestOxygen(`/api/cli/sequences${suffix ? `?${suffix}` : ""}`);
         }, formatSequenceListHealth);
@@ -1591,7 +1630,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .addHelpText("after", "\nSenders: each new lead gets one of the --sender-profiles people, the one with the fewest of this sequence's leads (a lead already talking to one of your LinkedIn accounts keeps that account's person), and its LinkedIn and email steps come from that person (email from one of their inboxes). Per step, in the steps file: email_send.sender_profile_id sends that email from any inbox of one selected person (the normal inbox rotation spreads leads across that person's inboxes and each lead keeps its one; a lead already assigned to that person keeps its own inbox; with none usable the lead waits, never using a colleague's inbox), and email_send.sender_mailbox_id from one exact inbox (set one or neither); a LinkedIn step's sender_profile_id sends it from one selected person. Invite, message, inmail and withdraw_invite steps must share one sender_profile_id or none: that person then owns every lead's LinkedIn thread (LinkedIn allows one of your accounts per conversation). visit_profile, follow, like_post and comment_post may each name anyone selected. An email whose From changes, including the return to the lead's inbox, needs its own subject_template. To check who sends each step, run `sequences start <sequence>` without --approved; nothing changes.\n")
         .requiredOption("--name <name>", "Human-readable sequence name.")
         .requiredOption("--slug <slug>", "Unique slug for the sequence.")
-        .requiredOption("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] }. LinkedIn steps (visit_profile | invite | wait_for_connection | message | inmail | follow | like_post | comment_post | withdraw_invite), email steps (email_send | email_enroll | email_move | email_stop), WhatsApp (whatsapp_message), human call tasks (call_task), connected-CRM tasks (crm_task; channel crm; exact identity record_mappings + explicit create/update policy + record_links + dynamic task property_mappings/associations), and control steps (wait | wait_for_signal | branch | stop), each with an `id`. Copy templates support {{column}} interpolation from the lead's row, {{column|fallback}} inline fallbacks, deterministic spintax — {{RANDOM|a|b|c}} or industry-standard bare {Hi|Hey|Hello}, nestable like {Would {Tuesday|Thursday} work|next week?} — and {% if column %}…{% endif %} conditionals; a bare {…} region is spintax only when it contains a top-level |, so literal braces (CSS/JSON) pass through. Every step's copy can also use {{sender_first_name}}, {{sender_last_name}} and {{sender_full_name}} (alias {{sender_name}}): the name of the person who sends that step (their sender profile, else the account or inbox display name), with no table column needed; email steps add {{sender_email}} (the from address). A row column of the same name WINS on collision, and a missing name renders empty. comment_post takes text_template and/or ai_prompt — a KG-grounded comment generated at send time (a paid AI call) that falls back to text_template if generation fails. A `branch` routes on signals (then/else) or the legacy connection_accepted/already_connected/open_profile sugar (then_id/else_id). A signal condition can also branch on the LEAD'S DATA: a contact leaf { has_contact: \"email\" | \"linkedin\" | \"phone\" } is true when that step's channel can reach the lead (resolved as sending resolves it; add present:false for \"missing\") — e.g. route leads that have an email down an email arm and the rest down a LinkedIn arm; a data leaf { has_column: \"<key>\" } tests one row_values column. MINIMAL EMAIL STEP SHAPE: { \"id\": \"s1\", \"channel\": \"email\", \"kind\": \"email_send\", \"subject_template\": \"...\", \"body_template\": \"...\" } — body_template is REQUIRED on email_send; subject_template is OPTIONAL and is the one control that decides threading: give a step its own subject and it goes out as a NEW email, omit it and the step continues the lead's previous email in the same thread, going out as \"Re: <the previous email's subject>\" (what the retired email_reply kind used to be — still accepted on input, rewritten into this shape, and reported under `warnings` in the response). The FIRST email step of a sequence must carry a subject, since it has no earlier thread to continue. MINIMAL WHATSAPP STEP SHAPE: { \"id\": \"s1\", \"channel\": \"whatsapp\", \"kind\": \"whatsapp_message\", \"template\": \"Hi {{first_name|there}} …\" } — template is REQUIRED, and a live WhatsApp start also needs the sequence's --whatsapp-cold-initiate opt-in. MINIMAL WAIT STEP SHAPE: { \"id\": \"w1\", \"kind\": \"wait\", \"days\": 3 } — days and/or hours, at least 1 hour in total. A/B tests use an explicit `variants` array of copy partials on the step (up to 25 alternates, a–z; spintax varies wording INSIDE one variant and is not A/B-tracked). For the complete replay-safe crm_task upsert mapping shape, read `oxygen skills get oxygen-sequencer --file references/calls-and-crm-tasks.md`.")
+        .requiredOption("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] }. LinkedIn steps (visit_profile | invite | wait_for_connection | message | inmail | follow | like_post | comment_post | withdraw_invite), email steps (email_send | email_enroll | email_move | email_stop), WhatsApp (whatsapp_message), human call tasks (call_task), connected-CRM tasks (crm_task; channel crm; exact identity record_mappings + explicit create/update policy + record_links + dynamic task property_mappings/associations), and control steps (wait | wait_for_signal | branch | stop), each with an `id`. Copy templates support {{column}} interpolation from the lead's row, {{column|fallback}} inline fallbacks, deterministic spintax — {{RANDOM|a|b|c}} or industry-standard bare {Hi|Hey|Hello}, nestable like {Would {Tuesday|Thursday} work|next week?} — and {% if column %}…{% endif %} conditionals; a bare {…} region is spintax only when it contains a top-level |, so literal braces (CSS/JSON) pass through. Every step's copy can also use {{sender_first_name}}, {{sender_last_name}} and {{sender_full_name}} (alias {{sender_name}}): the name of the person who sends that step (their sender profile, else the account or inbox display name), with no table column needed; email steps add {{sender_email}} (the from address). A row column of the same name WINS on collision, and a missing name renders empty. comment_post takes text_template and/or ai_prompt — a KG-grounded comment generated at send time (a paid AI call) that falls back to text_template if generation fails. A `branch` routes on signals (then/else) or the legacy connection_accepted/already_connected/open_profile sugar (then_id/else_id). A signal condition can also branch on the LEAD'S DATA: a contact leaf { has_contact: \"email\" | \"linkedin\" | \"phone\" } is true when that step's channel can reach the lead (resolved as sending resolves it; add present:false for \"missing\") — e.g. route leads that have an email down an email arm and the rest down a LinkedIn arm; a data leaf { has_column: \"<key>\" } tests one row_values column. MINIMAL EMAIL STEP SHAPE: { \"id\": \"s1\", \"channel\": \"email\", \"kind\": \"email_send\", \"subject_template\": \"...\", \"body_template\": \"...\" } — body_template is REQUIRED on email_send; subject_template is OPTIONAL and is the one control that decides threading: give a step its own subject and it goes out as a NEW email, omit it and the step continues the lead's previous email in the same thread, going out as \"Re: <the previous email's subject>\" (what the retired email_reply kind used to be — still accepted on input, rewritten into this shape, and reported under `warnings` in the response). The FIRST email step of a sequence must carry a subject, since it has no earlier thread to continue. MINIMAL WHATSAPP STEP SHAPE: { \"id\": \"s1\", \"channel\": \"whatsapp\", \"kind\": \"whatsapp_message\", \"template\": \"Hi {{first_name|there}} …\" } — template is REQUIRED, and a live WhatsApp start also needs the sequence's --whatsapp-cold-initiate opt-in. WAIT OPTIONS: add working_days:true to count schedule weekdays (Mon-Fri by default). On wait_for_connection, withdraw_on_timeout:true withdraws an unanswered invite under the normal sender limits before on_timeout stop/continue; configure it while draft. Existing wait steps may change working_days after start with the same step IDs, kinds and order; connection-wait settings remain locked (paused included). MINIMAL WAIT STEP SHAPE: { \"id\": \"w1\", \"kind\": \"wait\", \"days\": 3 } — days and/or hours, at least 1 hour in total. A/B tests use an explicit `variants` array of copy partials on the step (up to 25 alternates, a–z; spintax varies wording INSIDE one variant and is not A/B-tracked). For the complete replay-safe crm_task upsert mapping shape, read `oxygen skills get oxygen-sequencer --file references/calls-and-crm-tasks.md`.")
         .option("--channels <list>", "Comma-separated channels: linkedin,email,whatsapp,call,crm. Defaults to the channels the journey touches. crm_task currently supports HubSpot.")
         .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live — WhatsApp via Unipile is unofficial WhatsApp Web, so cold-initiating is an explicit ban-risk opt-in.")
         .addOption(new Option("--whatsapp-duplicate-scope <scope>", "Prevent duplicate WhatsApp copy in this campaign (default) or all campaigns.").choices(["campaign", "workspace"]))
@@ -1633,12 +1672,19 @@ 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("--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. There is no separate opt-out text: write any reply-to-stop line into the email copy. `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); 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("--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).")
         .option("--tracking-clicks", "Opt in to click tracking (default off). Requires a verified tracking domain and deployment tracking secret.")
         .option("--no-tracking-clicks", "Turn OFF click-link rewriting for this sequence's native email sends (links go out untouched).")
+        .addOption(new Option("--delivery <mode>", "How email steps leave: inboxes (default: the connected mailbox pool) or sending-domain (bulk mail to a subscription list's subscribers from one From address, through a sending domain in Sequencer → Accounts; unsubscribe link and headers always on, table rows never auto-enroll).").choices(["inboxes", "sending-domain"]))
+        .option("--sending-domain <idOrDomain>", "Sending-domain delivery: the sending domain, by id or domain name (e.g. news.acme.com).")
+        .option("--from-address <email>", "Sending-domain delivery: the From address, on the sending domain (and in its allowed From addresses, if it lists any).")
+        .option("--from-name <name>", "Sending-domain delivery: the From display name.")
+        .option("--reply-to-mailbox <id>", "Sending-domain delivery: the connected inbox id that receives answers. Defaults to the sending domain's Reply-To inbox.")
+        .option("--subscription-list <idOrKey>", "Sending-domain delivery: the subscription list, by id or key, whose subscribed addresses this sends to.")
         .option("--tags <csv>", "Comma-separated workspace tags linking this sequence to tables, workflows, and knowledge.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -1728,7 +1774,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .option("--activation-id <id>", "Guided activation UUID; requires --activation-revision and --expected-revision.")
         .option("--activation-revision <revision>", "Current guided activation revision; requires --activation-id and --expected-revision.")
         .option("--name <name>", "New human-readable sequence name.")
-        .option("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] } replacing the journey. Once started, only wait timing may change: same steps, same order (zero a delay, never delete its step). Copy supports {{column}} interpolation; every step also takes {{sender_first_name}} / {{sender_last_name}} / {{sender_full_name}} for the person who sends it, and email adds {{sender_email}} (a same-named row column wins). A `branch` can also route on the lead's data with a contact leaf { has_contact: \"email\" | \"linkedin\" | \"phone\" } or a data leaf { has_column: \"<key>\" } (present:false for \"missing\").")
+        .option("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] } replacing the journey. Once started (paused included), only existing wait steps may change days/hours/jitter_hours/working_days: same step IDs, kinds and order (zero a delay, never delete its step). Connection-wait timeout_days/on_timeout/withdraw_on_timeout are draft-only; duplicate to change them after start. Copy supports {{column}} interpolation; every step also takes {{sender_first_name}} / {{sender_last_name}} / {{sender_full_name}} for the person who sends it, and email adds {{sender_email}} (a same-named row column wins). A `branch` can also route on the lead's data with a contact leaf { has_contact: \"email\" | \"linkedin\" | \"phone\" } or a data leaf { has_column: \"<key>\" } (present:false for \"missing\").")
         .option("--channels <list>", "Draft only: comma-separated channels: linkedin,email,whatsapp,call,crm.")
         .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live (draft-editable).")
         .option("--no-whatsapp-cold-initiate", "WhatsApp: stop allowing cold chats; a live WhatsApp start then refuses.")
@@ -1737,7 +1783,7 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .option("--email-column-key <key>", "Native email: row_values key holding each lead's email (else falls back to email/email_address/work_email). Maps a non-English header (e.g. E-Mail). \"\" clears it back to auto-detect.")
         .option("--linkedin-url-column-key <key>", "LinkedIn: row_values key holding each lead's profile URL (else falls back to linkedin_url/linkedinUrl/linkedin/profile_url). \"\" clears it back to auto-detect.")
         .option("--senders <ids>", "LinkedIn or WhatsApp accounts attached directly, besides the --sender-profiles people's own accounts: comma-separated sender account ids (or connection / Unipile ids; `senders list` / `whatsapp accounts` list them). Replaces the directly attached set; \"\" removes them all and keeps the selected senders. `sequences get` lists both under sender_pool. Draft/paused only.")
-        .option("--source-table <idOrSlug>", "Bind the table this sequence enrolls leads from (id or slug). Only lands while the sequence has no source table yet (first-writer-wins); its rows become enrollable leads. Draft/paused only.")
+        .option("--source-table <idOrSlug>", "Bind the table this sequence enrolls leads from (id or slug). Draft/paused only. Rebinding preserves existing enrollments and their source-row provenance.")
         .option("--email-provider <provider>", "Optional linked-campaign provider: 'instantly'. Omit to preserve the existing binding; --clear-email removes it on a draft. Native email needs no provider binding and sends through connected Google/Microsoft mailboxes, including Microsoft SMTP transport.")
         .option("--email-connection <id>", "Instantly connection id for the email track.")
         .option("--email-definition-file <path>", "Path to a JSON file with the email content spec (subjects/bodies/delays/subsequences).")
@@ -1776,7 +1822,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", "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("--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. There is no separate opt-out text: write any reply-to-stop line into the email copy.")
+        .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("--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.")
@@ -1786,6 +1833,12 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .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).")
         .option("--tracking-clicks", "Opt in to click tracking (default off). Requires a verified tracking domain and deployment tracking secret.")
         .option("--no-tracking-clicks", "Turn OFF click-link rewriting for this sequence's native email sends (links go out untouched).")
+        .addOption(new Option("--delivery <mode>", "How email steps leave: inboxes (the connected mailbox pool; clears the sending-domain settings) or sending-domain (bulk mail to a subscription list's subscribers through a sending domain). Draft or paused to change the account or list.").choices(["inboxes", "sending-domain"]))
+        .option("--sending-domain <idOrDomain>", "Sending-domain delivery: the sending domain, by id or domain name. Any sending-domain flag alone keeps the other stored fields.")
+        .option("--from-address <email>", "Sending-domain delivery: the From address, on the sending domain.")
+        .option("--from-name <name>", "Sending-domain delivery: the From display name; \"\" clears it.")
+        .option("--reply-to-mailbox <id>", "Sending-domain delivery: the connected inbox id that receives answers; \"\" clears it.")
+        .option("--subscription-list <idOrKey>", "Sending-domain delivery: the subscription list, by id or key, whose subscribed addresses this sends to.")
         .option("--tags <csv>", "Replace the sequence's workspace tags (comma-separated; \"\" clears them). The ONE field an ARCHIVED sequence still accepts — tag finished campaigns to link their learnings across the workspace.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
@@ -1877,10 +1930,12 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         await handleAsyncAction("sequences get", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}${query}`));
     }))
         .addCommand(new Command("enroll")
-        .description("Enroll leads into a sequence. Enrolling spends no credits. An active sequence contacts the new leads on its next dispatch tick; a draft or paused one holds them until `sequences start`. --from-table enrolls every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; the response's from_table.has_more says whether to run again) — for a LinkedIn sequence the profile is read from the bound table's URL column, where a full /in/ URL and a bare public handle carrying a hyphen or digit (ada-lovelace) both work, so no pre-resolved provider ids are needed; each handle Oxygen canonicalized is echoed in linkedin_handles_canonicalized (value + url) to check before start, and every row that still cannot be resolved is named in unresolved_linkedin_lead_details (row, value, reason) rather than only counted in unresolved_linkedin_leads. In a sequence with LinkedIn steps a row with no usable profile is still enrolled when its email or phone reaches the journey's email, call or WhatsApp steps (its LinkedIn steps are skipped as no_linkedin_profile, a connection wait passes at once and a connection branch takes its not-connected path) and is listed in linkedin_unavailable_lead_details instead, with channels naming what reaches it; unresolved_linkedin_leads names only rows that were not enrolled. --leads-file enrolls an explicit JSON list { leads: [...] }: for an email/WhatsApp sequence a lead identified only by an email (row_values.email) or phone (row_values.phone) is auto-filed as a row in the sequence's leads table (auto-creating and binding one if there is none), deduped by email/phone, so no table has to exist first (the table is returned as leads_table with a web_url); a LinkedIn + email sequence auto-files an email-only lead the same way; a LinkedIn lead needs a lead_provider_id, a lead_profile_url (a /in/ URL or a bare public handle with a hyphen or digit), or a table_row_id whose row carries one of those; in a sequence with LinkedIn steps a lead with a lead_profile_url and no table_row_id is filed the same way, onto the person's existing row in the bound table (another spelling of the same profile URL matches) or as a new row, deduped by profile URL, and a person the sequence already holds keeps that enrollment; where the sequence has no table and every new table needs a client signoff the enroll is refused instead (sequence_leads_table_needs_signoff). Like any table-row lead a filed one cannot re-enroll in that sequence once its enrollment ends; leads_without_table_row counts the leads in the request that no table lists (those given only a lead_provider_id, and people the sequence already holds without a row). A CRM-only lead needs a stable table_row_id or lead_provider_id in addition to mapped row_values; a HubSpot contact id used in crm_task associations identifies the destination record, not the Oxygen enrollment. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row (and per email/phone or profile URL for auto-filed leads). WhatsApp-only campaigns also enroll each normalized number once across all source rows and enrollment statuses; mixed campaigns keep other channels and skip duplicate WhatsApp actions. Duplicate protection defaults to this campaign; --whatsapp-duplicate-scope on create/update can additionally block identical copy across all campaigns. The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason). Leads already owned by a sender account (from an earlier real send) are routed back to that same account; a lead owned by a sender NOT on this sequence is skipped (bound_to_other_sender) unless --ignore-sender-bindings. This enrolls into an OXYGEN Sequence; to put the same rows into a campaign you already run in Smartlead, Instantly, lemlist or HeyReach, use `sequences push-external`. esp.pool_scope identifies the active workspace inventory used for routing and strict_deferred_leads estimates; these estimates omit sequence sender restrictions, readiness and daily limits. A zero estimate does not guarantee readiness. Review sequences preview before launch.")
+        .description("Enroll leads into a sequence. Enrolling spends no credits. An active sequence contacts the new leads on its next dispatch tick; a draft or paused one holds them until `sequences start`. --from-table enrolls every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; the response's from_table.has_more says whether to run again) — for a LinkedIn sequence the profile is read from the bound table's URL column, where a full /in/ URL and a bare public handle carrying a hyphen or digit (ada-lovelace) both work, so no pre-resolved provider ids are needed; each handle Oxygen canonicalized is echoed in linkedin_handles_canonicalized (value + url) to check before start, and every row that still cannot be resolved is named in unresolved_linkedin_lead_details (row, value, reason) rather than only counted in unresolved_linkedin_leads. In a mixed journey a row with no usable LinkedIn profile still enrolls when its email or phone reaches another step, or it has a stable table_row_id or lead_provider_id for crm_task steps. CRM tasks do not require email, LinkedIn or phone; their configured record identities and property mappings are validated when planned. Missing-channel steps are skipped; LinkedIn skips use no_linkedin_profile, a connection wait passes at once and a connection branch takes its not-connected path. These rows appear in linkedin_unavailable_lead_details; unresolved_linkedin_leads names only rows that were not enrolled. --leads-file enrolls an explicit JSON list { leads: [...] }: for an email/WhatsApp sequence a lead identified only by an email (row_values.email) or phone (row_values.phone) is auto-filed as a row in the sequence's leads table (auto-creating and binding one if there is none), deduped by email/phone, so no table has to exist first (the table is returned as leads_table with a web_url); a LinkedIn + email sequence auto-files an email-only lead the same way; a LinkedIn lead needs a lead_provider_id, a lead_profile_url (a /in/ URL or a bare public handle with a hyphen or digit), or a table_row_id whose row carries one of those; in a sequence with LinkedIn steps a lead with a lead_profile_url and no table_row_id is filed the same way, onto the person's existing row in the bound table (another spelling of the same profile URL matches) or as a new row, deduped by profile URL, and a person the sequence already holds keeps that enrollment; where the sequence has no table and every new table needs a client signoff the enroll is refused instead (sequence_leads_table_needs_signoff). Like any table-row lead a filed one cannot re-enroll in that sequence once its enrollment ends; leads_without_table_row counts the leads in the request that no table lists (those given only a lead_provider_id, and people the sequence already holds without a row). A CRM-task lead in a CRM-only or mixed journey needs a stable table_row_id or lead_provider_id in addition to mapped row_values; a HubSpot contact id used in crm_task associations identifies the destination record, not the Oxygen enrollment. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row (and per email/phone or profile URL for auto-filed leads). WhatsApp-only campaigns also enroll each normalized number once across all source rows and enrollment statuses; mixed campaigns keep other channels and skip duplicate WhatsApp actions. Duplicate protection defaults to this campaign; --whatsapp-duplicate-scope on create/update can additionally block identical copy across all campaigns. The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason). Leads already owned by a sender account (from an earlier real send) are routed back to that same account; a lead owned by a sender NOT on this sequence is skipped (bound_to_other_sender) unless --ignore-sender-bindings. This enrolls into an OXYGEN Sequence; to put the same rows into a campaign you already run in Smartlead, Instantly, lemlist or HeyReach, use `sequences push-external`. esp.pool_scope identifies the active workspace inventory used for routing and strict_deferred_leads estimates; these estimates omit sequence sender restrictions, readiness and daily limits. A zero estimate does not guarantee readiness. Review sequences preview before launch.")
         .argument("<sequence>", "Sequence id or slug.")
-        .option("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ row_values: { email }, lead_name }] } for cold email; { lead_profile_url, lead_name, row_values } or { lead_provider_id, lead_name, table_row_id, row_values } for LinkedIn/existing rows; CRM-only leads require table_row_id or a stable lead_provider_id alongside mapped row_values. A CRM association object id is not the enrollment identity. Exactly one of --leads-file or --from-table.")
-        .option("--from-table", "Enroll every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; re-run to continue). Exactly one of --leads-file or --from-table.")
+        .option("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ row_values: { email }, lead_name }] } for cold email; { lead_profile_url, lead_name, row_values } or { lead_provider_id, lead_name, table_row_id, row_values } for LinkedIn/existing rows; CRM-task leads in single/mixed journeys require table_row_id or a stable lead_provider_id alongside mapped row_values. A CRM association object id is not the enrollment identity. Exactly one of --leads-file, --from-table or --from-list.")
+        .option("--from-table", "Enroll every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; re-run to continue). Exactly one of --leads-file, --from-table or --from-list.")
+        .option("--from-list <idOrKey>", "Sending-domain Sequences: enroll up to 500 subscribed addresses of the Sequence's own subscription list per run, each filed as an email-only lead in its leads table (another list is refused: sequence_from_list_mismatch). Re-run with --from-list-after <from_list.next_after> while from_list.has_more.")
+        .option("--from-list-after <email>", "With --from-list: continue after this address (the previous run's from_list.next_after).")
         .option("--exclude-contacted", "Also skip leads any OTHER active sequence is already contacting (cross-campaign exclusion), for THIS enroll. Off by default; forces exclusion on even if the sequence's exclude_contacted default is off.")
         .option("--no-exclude-contacted", "Force-INCLUDE cross-campaign leads for this enroll even when the sequence's exclude_contacted default is on (per-call override).")
         .option("--suppress-list <ids>", "Per-call do-not-enroll lead provider ids dropped for this enroll only: a comma-separated list, or @<path> to a file of ids (comma/whitespace separated).")
@@ -1889,11 +1944,12 @@ export function registerSequencesFamily(program, handleAsyncAction) {
         .action(async (sequence, options) => {
         await handleAsyncAction("sequences enroll", options, () => {
             const leadsPath = readOption(options.leadsFile);
-            if (options.fromTable && leadsPath) {
-                throw new Error("Provide exactly one of --leads-file or --from-table.");
+            const fromList = readOption(options.fromList);
+            if ([Boolean(options.fromTable), Boolean(leadsPath), Boolean(fromList)].filter(Boolean).length !== 1) {
+                throw new Error("Provide exactly one of --leads-file, --from-table or --from-list.");
             }
-            if (!options.fromTable && !leadsPath) {
-                throw new Error("Provide exactly one of --leads-file or --from-table.");
+            if (options.fromListAfter !== undefined && !fromList) {
+                throw new Error("--from-list-after needs --from-list.");
             }
             const suppressList = parseSuppressListOption(options.suppressList);
             const sharedFlags = {
@@ -1909,6 +1965,13 @@ export function registerSequencesFamily(program, handleAsyncAction) {
                     body: { from_table: true, ...sharedFlags },
                 });
             }
+            if (fromList) {
+                const after = readOption(options.fromListAfter);
+                return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enroll`, {
+                    method: "POST",
+                    body: { from_list: fromList, ...(after ? { from_list_after: after } : {}), ...sharedFlags },
+                });
+            }
             const parsed = readJsonFileValue(resolve(leadsPath), "--leads-file");
             return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enroll`, {
                 method: "POST",

package/dist/commands/subscriptions.d.ts

@@ -0,0 +1,10 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+type ImportEntry = {
+    email: string;
+    person_id?: string;
+};
+/** 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;
+export {};

package/dist/commands/subscriptions.js

@@ -0,0 +1,203 @@
+import { requestOxygen } from "../http-client.js";
+import { isRecord, readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+function evidenceBody(options) {
+    const noticeVersion = readOption(options.noticeVersion);
+    const noticeTextHash = readOption(options.noticeTextHash);
+    const formUrl = readOption(options.formUrl);
+    const basis = readOption(options.basis);
+    const evidence = {
+        ...(noticeVersion ? { notice_version: noticeVersion } : {}),
+        ...(noticeTextHash ? { notice_text_hash: noticeTextHash } : {}),
+        ...(formUrl ? { form_url: formUrl } : {}),
+        ...(basis ? { basis } : {}),
+    };
+    return Object.keys(evidence).length > 0 ? evidence : undefined;
+}
+function requireSubscribeEvidence(options, status) {
+    if (status !== "subscribed")
+        return;
+    const notice = readOption(options.noticeVersion) && readOption(options.noticeTextHash);
+    if (!notice && !readOption(options.basis)) {
+        throw new OxygenError("consent_evidence_required", "Subscribing needs consent evidence: --notice-version with --notice-text-hash, or --basis naming where consent came from.", { details: { field: "evidence" }, exitCode: 2 });
+    }
+}
+/** Split one CSV line, honouring double-quoted fields with "" escapes. */
+function splitCsvLine(line) {
+    const cells = [];
+    let cell = "";
+    let quoted = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (quoted) {
+            if (char === "\"" && line[index + 1] === "\"") {
+                cell += "\"";
+                index += 1;
+            }
+            else if (char === "\"")
+                quoted = false;
+            else
+                cell += char;
+        }
+        else if (char === "\"")
+            quoted = true;
+        else if (char === ",") {
+            cells.push(cell.trim());
+            cell = "";
+        }
+        else
+            cell += char;
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+function csvEntries(text) {
+    const lines = text.replace(/^/, "").split(/\r?\n/).filter((line) => line.trim());
+    const header = splitCsvLine(lines[0] ?? "").map((cell) => cell.toLowerCase());
+    const emailIndex = header.findIndex((cell) => cell === "email" || cell === "email_address" || cell === "e-mail");
+    if (emailIndex < 0) {
+        throw new OxygenError("invalid_request", "The CSV needs an email column in its header row.", { exitCode: 2 });
+    }
+    const personIndex = header.findIndex((cell) => cell === "person_id");
+    return lines.slice(1).map((line) => {
+        const cells = splitCsvLine(line);
+        const personId = personIndex >= 0 ? cells[personIndex] : undefined;
+        return { email: cells[emailIndex] ?? "", ...(personId ? { person_id: personId } : {}) };
+    });
+}
+function jsonEntries(value) {
+    const list = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.entries) ? value.entries : null;
+    if (!list) {
+        throw new OxygenError("invalid_request", "The JSON file must be a list of emails or { email, person_id } objects, or { entries: [...] }.", { exitCode: 2 });
+    }
+    return list.map((entry) => {
+        if (typeof entry === "string")
+            return { email: entry };
+        if (isRecord(entry) && typeof entry.email === "string") {
+            return { email: entry.email, ...(typeof entry.person_id === "string" ? { person_id: entry.person_id } : {}) };
+        }
+        return { email: "" };
+    });
+}
+/** Read --file as JSON (by extension or content) or as CSV with an email column. */
+export function readSubscriptionImportFile(path) {
+    const text = readFileSync(resolve(path), "utf8");
+    const trimmed = text.trim();
+    if (path.toLowerCase().endsWith(".json") || trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            throw new OxygenError("invalid_request", "--file is not valid JSON.", { exitCode: 2 });
+        }
+        return jsonEntries(parsed);
+    }
+    return csvEntries(text);
+}
+function requireFlag(value, flag) {
+    const read = readOption(value);
+    if (!read)
+        throw new OxygenError("invalid_request", `${flag} is required.`, { exitCode: 2 });
+    return read;
+}
+function runSubscriptionsSet(email, options) {
+    const list = requireFlag(options.list, "--list");
+    const status = requireFlag(options.status, "--status");
+    requireSubscribeEvidence(options, status);
+    const source = readOption(options.source);
+    const evidence = evidenceBody(options);
+    return requestOxygen("/api/cli/subscriptions", {
+        method: "POST",
+        body: {
+            list,
+            email,
+            status,
+            ...(source ? { source } : {}),
+            ...(evidence ? { evidence } : {}),
+        },
+    });
+}
+function runSubscriptionsImport(options) {
+    const list = requireFlag(options.list, "--list");
+    const source = requireFlag(options.source, "--source");
+    const status = readOption(options.status) ?? "subscribed";
+    requireSubscribeEvidence(options, status);
+    const entries = readSubscriptionImportFile(requireFlag(options.file, "--file"));
+    const evidence = evidenceBody(options);
+    return requestOxygen("/api/cli/subscriptions/import", {
+        method: "POST",
+        body: {
+            list,
+            entries,
+            status,
+            source,
+            ...(evidence ? { evidence } : {}),
+        },
+    });
+}
+function addEvidenceFlags(command) {
+    return command
+        .option("--notice-version <version>", "Version of the consent notice the person saw (with --notice-text-hash).")
+        .option("--notice-text-hash <sha256>", "sha256 hex of the exact consent notice text shown.")
+        .option("--form-url <url>", "Where the person gave consent.")
+        .option("--basis <text>", "Where consent came from, e.g. \"Webinar signup form, Oct 2026\".");
+}
+export function registerSubscriptionsFamily(program, handleAsyncAction) {
+    program.addCommand(new Command("subscriptions")
+        .description("Subscription lists and consent for bulk email: who agreed to hear from you (newsletter, product updates, onboarding). Sending-domain Sequences send only to subscribed addresses on their list, on top of do-not-contact. Every change records its consent evidence. 0 credits.")
+        .addCommand(new Command("lists")
+        .description("Subscription lists.")
+        .addCommand(new Command("list")
+        .description("List subscription lists with subscribed, unsubscribed, pending and cleaned counts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("subscriptions lists list", options, () => requestOxygen("/api/cli/subscriptions/lists"));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a subscription list.")
+        .argument("<key>", "Stable key: lowercase letters, digits, - and _, such as newsletter.")
+        .requiredOption("--name <name>", "Display name.")
+        .requiredOption("--kind <kind>", "marketing, product_updates or onboarding.")
+        .option("--description <text>", "What subscribers get.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (key, options) => {
+        await handleAsyncAction("subscriptions lists create", options, () => {
+            const description = readOption(options.description);
+            return requestOxygen("/api/cli/subscriptions/lists", {
+                method: "POST",
+                body: { key, name: options.name, kind: options.kind, ...(description ? { description } : {}) },
+            });
+        });
+    })))
+        .addCommand(new Command("get")
+        .description("Show one address's status on every list it is on.")
+        .argument("<email>", "Email address.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (email, options) => {
+        await handleAsyncAction("subscriptions get", options, () => requestOxygen(`/api/cli/subscriptions?${new URLSearchParams({ email }).toString()}`));
+    }))
+        .addCommand(addEvidenceFlags(new Command("set")
+        .description("Set one address's status on one list and record the consent event. Subscribing needs evidence.")
+        .argument("<email>", "Email address.")
+        .requiredOption("--list <key-or-id>", "Subscription list key or id.")
+        .requiredOption("--status <status>", "subscribed, unsubscribed, pending or cleaned.")
+        .option("--source <source>", "Where this change came from (default api)."))
+        .option("--json", "Print a JSON envelope.")
+        .action(async (email, options) => {
+        await handleAsyncAction("subscriptions set", options, () => runSubscriptionsSet(email, options));
+    }))
+        .addCommand(addEvidenceFlags(new Command("import")
+        .description("Import up to 5,000 addresses onto one list under one consent evidence record. --file is JSON (emails or { email, person_id }) or CSV with an email column. Addresses cleaned by a complaint or hard bounce stay off; invalid rows are reported by index.")
+        .requiredOption("--list <key-or-id>", "Subscription list key or id.")
+        .requiredOption("--file <path>", "JSON or CSV file of addresses.")
+        .requiredOption("--source <source>", "Where these addresses came from, e.g. webinar_2026_10.")
+        .option("--status <status>", "Status to set (default subscribed)."))
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("subscriptions import", options, () => runSubscriptionsImport(options));
+    })));
+}

package/dist/commands/tags.js

@@ -36,7 +36,7 @@ function tagRegistryBody(options) {
 export function registerTagsFamily(program, handleAsyncAction) {
     program
         .command("tags")
-        .description(`Workspace tags: one vocabulary across ${TAG_KINDS_PROSE}. Tags normalize to lowercase (trimmed, deduped, max 50 per item; any characters — nothing is slugified, so "Q3 Outbound" becomes "q3 outbound"). ATTACH with a carrier's own tag command (e.g. \`oxygen inbox tag\`, \`oxygen tables tag\`) or use \`oxygen tags attach <kind> <ref> --tags <labels>\` for Signal types, saved Dashboards, runtime Agents, and saved Ads searches. Then \`tags get <tag>\` returns every carrier with deep-links. CURATE the vocabulary here: \`tags create\` declares a tag (with a description, color, and pin) before anything carries it, \`tags update\` re-annotates one, and \`tags rename\`/\`merge\`/\`delete\` reshape it everywhere at once. Tags are free, inert metadata: attaching or removing one costs 0 credits, makes no provider call, and changes no sending, routing, or warm-up behaviour.`)
+        .description(`Workspace tags: one vocabulary across ${TAG_KINDS_PROSE}. Tags preserve entered case (trimmed, deduped case-insensitively, max 50 per item). ATTACH with a carrier's own tag command (e.g. \`oxygen inbox tag\`, \`oxygen tables tag\`) or use \`oxygen tags attach <kind> <ref> --tags <labels>\` for Signal types, saved Dashboards, runtime Agents, and saved Ads searches. Then \`tags get <tag>\` returns every carrier with deep-links. CURATE the vocabulary here: \`tags create\` declares a tag (with a description, color, and pin) before anything carries it, \`tags update\` re-annotates one, and \`tags rename\`/\`merge\`/\`delete\` reshape it everywhere at once. Tags are free, inert metadata: attaching or removing one costs 0 credits, makes no provider call, and changes no sending, routing, or warm-up behaviour.`)
         .addCommand(new Command("list")
         .description("List every workspace tag with per-primitive counts, most-used first.")
         .option("--json", "Print a JSON envelope.")
@@ -56,9 +56,9 @@ export function registerTagsFamily(program, handleAsyncAction) {
                 : `/api/cli/tags/${encodeURIComponent(tag)}`));
     }))
         .addCommand(new Command("rename")
-        .description("Rename one tag EVERYWHERE it appears (every primitive, archived rows included). Preview-first: without --apply, prints per-kind would-change counts and mutates nothing. Idempotent — safe to re-run after a partial failure.")
+        .description("Rename one tag EVERYWHERE it appears (every primitive, archived rows included). Preview-first: without --apply, prints per-kind would-change counts and mutates nothing. Case-only renames are supported (e.g. event name capitalization), preserving the new spelling while matching case-insensitively. Idempotent — safe to re-run after a partial failure.")
         .argument("<from>", "The current tag (case-insensitive).")
-        .argument("<to>", "The new tag (normalized lowercase).")
+        .argument("<to>", "The new tag (case preserved; matching ignores case).")
         .option("--apply", "Execute the rename. Without this flag, returns a preview of the counts only.")
         .option("--json", "Print a JSON envelope.")
         .action(async (from, to, options) => {
@@ -69,7 +69,7 @@ export function registerTagsFamily(program, handleAsyncAction) {
     }))
         .addCommand(new Command("create")
         .description("Declare a tag before anything carries it, with an optional description, color, and pin. Idempotent: run it on a tag already in use to annotate it — carriers are never touched.")
-        .argument("<label>", "The tag (normalized to lowercase; spaces are kept, nothing is slugified).")
+        .argument("<label>", "The tag (case and spaces preserved; matching ignores case).")
         .option("--description <text>", "What this tag means in this workspace.")
         .option("--color <color>", `Pill color. One of: ${TAG_COLORS.join(", ")}. Omit to derive it from the label.`)
         .option("--pinned", "Pin it to the top of the tag list and the tag picker.")

package/dist/customer-operation-commands.js

@@ -9,6 +9,10 @@ import { requestOxygen } from "./http-client.js";
 // Only newly registered groups use these purposes; manual owners retain their
 // descriptions, aliases and children.
 const GROUP_PURPOSES = {
+    chat: "Dev only: persistent workspace support threads and shared files.",
+    "chat threads": "Dev only: create and continue native support threads.",
+    "chat files": "Dev only: upload and download files in a native support thread.",
+    "chat admin": "Staff only. Dev native support channels, priority and customer significance.",
     "copilot policy": "Set an attended Copilot session's approval policy.",
     "context canonical": "Read the workspace's pinned canonical context asset.",
     "directory logo": "Upload the public agency listing's logo.",
@@ -108,6 +112,19 @@ export function registerCustomerOperationCommands(program, handle) {
                 option.makeOptionMandatory();
             }
         }
+        // Commander validates mandatory leaf options before preAction/action hooks.
+        // Recover explicitly typed ancestor flags after reset, before leaf parsing.
+        parent.hook("preSubcommand", (_parent, selected) => {
+            if (selected !== command)
+                return;
+            const inherited = ancestorConsumedOptions(command, selected, command.opts());
+            for (const option of command.options) {
+                const key = option.attributeName();
+                if (command.getOptionValue(key) === undefined && inherited[key] !== undefined) {
+                    command.setOptionValueWithSource(key, inherited[key], "cli");
+                }
+            }
+        });
         command.action((options, selected) => handle(spec.cli.path.join(" "), { ...options, json: selected.optsWithGlobals().json === true }, async () => {
             let input;
             try {

package/dist/mailbox-fleet-output.d.ts

@@ -0,0 +1,3 @@
+/** Fleet evidence precedes identity rows in both the native JSON and text views. */
+export declare function formatMailboxFleetHealth(data: Record<string, unknown>): string;
+export declare function formatMailboxRoster(data: Record<string, unknown>): string;

package/dist/mailbox-fleet-output.js

@@ -0,0 +1,80 @@
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function count(value) { return typeof value === "number" ? String(value) : "unknown"; }
+function text(value) { return typeof value === "string" ? value : "unknown"; }
+function counts(value) {
+    const entries = Object.entries(record(value));
+    return entries.length ? entries.map(([key, value]) => `${key} ${count(value)}`).join(" · ") : "none reported";
+}
+/** Fleet evidence precedes identity rows in both the native JSON and text views. */
+export function formatMailboxFleetHealth(data) {
+    const coverage = record(data.health_coverage);
+    const signals = record(data.signals);
+    const warmup = record(data.warmup);
+    const summary = record(data.fleet_summary);
+    const score = typeof summary.score === "number" && Number.isFinite(summary.score) ? `${summary.score.toFixed(1)}/100` : "unmeasured";
+    const lines = [
+        `Fleet: ${count(coverage.total)} inboxes · ${text(data.fleet_state)}`,
+        ...(Object.keys(summary).length ? [
+            `Recorded health: ${score} · ${count(summary.scored)}/${count(summary.total ?? coverage.total)} scored · ${text(summary.coverage)} coverage · ${text(summary.freshness)} freshness${typeof summary.unverified === "number" && summary.unverified > 0 ? ` · ${count(summary.unverified)} unverified` : ""}`,
+        ] : []),
+        `Health coverage: ${text(coverage.state)} · ${count(coverage.externally_scored)} externally scored · ${count(coverage.unknown)} unknown`,
+        `Health bands: ${counts(data.counts)}`,
+        `Signals: ${signals.available === false ? "UNAVAILABLE (counts unread)" : signals.available === true ? "available" : "unknown"} · window ${text(signals.window)} · send source ${text(signals.sendSource)}`,
+        "Evidence scope: delivery notifications include all send sources; only coldSends7d counts sequence sends. Unattributed rejections do not establish that prospect mail was rejected or that a whole domain is blocked.",
+        `Delivery notifications: ${counts(signals.dsn7d)}${signals.dsnScanTruncated === true ? " (scan truncated; lower bounds)" : ""}`,
+        `Sequence sends: ${count(signals.coldSends7d)} · hard bounces ${count(signals.hardBounces7d)} · provider rejections ${count(signals.providerRejections7d)} · Google rejections ${count(signals.googleRejections7d)}`,
+        `Stored warm-up rail states: ${counts(warmup.byState)}`,
+        `Warm-up stop causes: ${counts(warmup.byCause)}`,
+        "Enrollment and next actions: oxygen mailboxes list --json (warmupTruth).",
+        "",
+        "Domains (worst first):",
+    ];
+    const domains = Array.isArray(data.domains) ? data.domains.map(record) : [];
+    for (const domain of domains)
+        lines.push(`  ${text(domain.domain)} · ${count(domain.mailboxes)} inboxes · provider rejections ${count(domain.providerRejections7d)} (Google ${count(domain.googleRejections7d)}) · hard bounces ${count(domain.hardBounces7d)} / ${count(domain.coldSends7d)} sequence sends · youngest warm-up day ${count(domain.warmupDayMin)}`);
+    if (!domains.length)
+        lines.push("  None reported.");
+    const recommendations = Array.isArray(data.recommendations)
+        ? data.recommendations.filter((value) => typeof value === "string" && value.trim().length > 0)
+        : [];
+    if (recommendations.length) {
+        lines.push("", "Recommendations (directional):");
+        for (const recommendation of recommendations.slice(0, 16)) {
+            const message = recommendation.trim();
+            lines.push(`  ${message.length > 1_000 ? `${message.slice(0, 1_000)}… (truncated; use --json)` : message}`);
+        }
+        if (recommendations.length > 16)
+            lines.push(`  ${recommendations.length - 16} more recommendation(s); use --json for the complete response.`);
+    }
+    const mailboxes = Array.isArray(data.mailboxes) ? data.mailboxes.map(record) : null;
+    if (mailboxes) {
+        lines.push("", `Inbox roster (${mailboxes.length}):`);
+        for (const mailbox of mailboxes) {
+            const mailboxWarmup = record(mailbox.warmup);
+            const warnings = Array.isArray(mailbox.warnings) ? mailbox.warnings.join(", ") : "";
+            lines.push(`  ${text(mailbox.emailAddress)} · ${text(mailbox.status)} · health ${text(mailbox.healthState)} (${text(mailbox.healthFreshness)}) · stored warm-up rail ${text(mailboxWarmup.state)}${typeof mailboxWarmup.pauseCode === "string" ? ` / ${mailboxWarmup.pauseCode}` : ""}${warnings ? ` · ${warnings}` : ""}`);
+        }
+    }
+    else if (data.view === "fleet")
+        lines.push("", "Inbox rows omitted by --view fleet; use --view summary for the complete roster.");
+    lines.push("", "Directional evidence; unavailable or unknown readings are not a health clearance.");
+    const link = data.web_url ?? data.deepLink;
+    if (typeof link === "string")
+        lines.push(link);
+    return `${lines.join("\n")}\n`;
+}
+export function formatMailboxRoster(data) {
+    const summary = record(data.summary);
+    const lines = [`Mailbox pool: ${count(data.count ?? summary.total)} inboxes`,
+        `Providers: ${counts(summary.by_provider)}`, `Status: ${counts(summary.by_status)}`,
+        `Transport: ${counts(summary.by_transport)}`, `Warm-up: ${counts(record(summary.warmup).by_truth_state)}`, ""];
+    const mailboxes = Array.isArray(data.mailboxes) ? data.mailboxes.map(record) : [];
+    for (const mailbox of mailboxes)
+        lines.push(`  ${text(mailbox.emailAddress)} · ${text(mailbox.provider)} · ${text(mailbox.status)} · ${text(mailbox.transport)} · warm-up ${text(record(mailbox.warmupTruth).state ?? mailbox.warmupState)} · next ${text(record(record(mailbox.warmupTruth).next_action).code)}`);
+    lines.push("", "Inspect an inbox: oxygen mailboxes get <id-or-address> --json");
+    if (typeof data.web_url === "string")
+        lines.push(data.web_url);
+    return `${lines.join("\n")}\n`;
+}

package/dist/native-chat-host.d.ts

@@ -0,0 +1,2 @@
+/** Offline help cannot inspect a server flag; native chat is discoverable only for a dev API host. */
+export declare function nativeChatHostServed(env?: NodeJS.ProcessEnv): boolean;

package/dist/native-chat-host.js

@@ -0,0 +1,6 @@
+import { defaultApiUrl } from "./credentials.js";
+import { isProdApiUrl } from "./runtime.js";
+/** Offline help cannot inspect a server flag; native chat is discoverable only for a dev API host. */
+export function nativeChatHostServed(env = process.env) {
+    return !isProdApiUrl(defaultApiUrl(env)) && !/^(0|false|off)$/i.test(env.OXYGEN_NATIVE_CHAT_ENABLED?.trim() ?? "");
+}