@oxygen-agent/cli 1.1010.954 → 1.1011.95

package/dist/index.js

@@ -27,6 +27,7 @@ import { addContractFlags } from "./contract-flags.js";
 import { buildSenderLimitsBody, parseWorkingDaysOption, SENDER_LIMITS_FLAG_OVERLAY } from "./sender-limits-flags.js";
 import { readColumnDecisionFlags } from "./column-decision-options.js";
 import { MANAGED_DATA_SUPPLIERS } from "@oxygen/shared/data-suppliers";
+import { COMPANY_REPLY_PAUSE_DEFAULT_STATUSES, COMPANY_REPLY_PAUSE_LEGACY_STATUSES, COMPANY_REPLY_PAUSE_STATUS_KEY_PATTERN, } from "@oxygen/shared/company-reply-pause";
 import { MAX_BUFFERED_IMPORT_PARSE_BYTES, assertImportFormatWithinBufferedLimit, inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
 import { MAILBOX_IMPORT_FILE_MAX_BYTES as SHARED_MAILBOX_IMPORT_FILE_MAX_BYTES, MAILBOX_IMPORT_ROW_LIMIT as SHARED_MAILBOX_IMPORT_ROW_LIMIT, normalizeMailboxImportFile as normalizeSharedMailboxImportFile, normalizeMailboxImportVendor as normalizeSharedMailboxImportVendor, normalizeMailboxWorkbookRows, parseMailboxImportText, summarizeMailboxImportValidation as summarizeSharedMailboxImportValidation, } from "@oxygen/shared/mailbox-import";
 import { assertRecipeBundleSafe, assertPortableWorkflowDefinition, assertWorkflowGraphManifest, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowGraphManifest, isWorkflowManifest, hashPortableWorkflowGraphManifest, WORKFLOW_GRAPH_COMPILER_VERSION, WORKFLOW_GRAPH_MANIFEST_VERSION, } from "@oxygen/workflows";
@@ -3685,9 +3686,9 @@ export function createProgram() {
     // `oxygen workspace map` sits beside `oxygen home` on purpose: home answers
     // "what needs me", the map answers "what is in here". Both are Control-surface
     // compositions over reads the primitives already own — neither is a primitive.
-    program
+    const workspaceCommand = program
         .command("workspace")
-        .description("Read what this workspace contains, across every primitive.")
+        .description("Inspect this workspace or end its managed external infrastructure.")
         .addCommand(new Command("map")
         .description("What this workspace actually contains: the newest tables, CRM objects, sequences, workflows, agents, wiki pages, posts and projects, each with its id, last activity, tags and link. Read-only, 0 credits. Capability search tells you what OXYGEN can do; this tells you what is here.")
         .option("--kind <kinds>", "Comma-separated kinds to include: table, crm_object, sequence, workflow, agent, knowledge_page, post, project.")
@@ -3714,6 +3715,22 @@ export function createProgram() {
             return data;
         });
     }));
+    workspaceCommand.addCommand(new Command("infrastructure-exit")
+        .description("Leave, close or offboard a workspace's managed external infrastructure in one action. Preview every renewing resource and its release-timing note, then with --approved stop renewals and begin provider teardown. Known paid terms are honored; some dates are estimated or unavailable. Sending connections are disconnected; records and history remain. Requires an exact workspace confirmation and the fresh preview hash. Free, 0 credits.")
+        .option("--approved", "Begin the approved teardown.")
+        .option("--confirm <workspace>", "Echo the exact workspace slug or ID from the preview.")
+        .option("--plan-hash <hash>", "The plan_hash from the immediately preceding preview.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("workspace infrastructure exit", options, () => requestOxygen("/api/cli/workspace/infrastructure/exit", {
+            method: "POST",
+            body: {
+                approved: options.approved === true,
+                confirm_workspace: options.confirm ?? null,
+                plan_hash: options.planHash ?? null,
+            },
+        }));
+    }));
     const ACTIVATION_DESCRIPTION = "Where this workspace stands in the prescribed activation play (inbound-led outbound) and the ONE thing to do next: each step's state, what blocks a blocked one, the exact CLI / MCP tool / API call for the next step, and an honest pacing note — LinkedIn is read on a metered drip and a sender's warm-up ramp, not the size of your list, sets how fast anyone is contacted. Read-only, 0 credits. Read the play itself with `oxygen recipes list --stage day-1 --json`.";
     // Bare `oxygen activation` is the spelling a founder guesses; `activation state`
     // is the exact name discovery routes to (it is a gatewayCommand of the
@@ -4347,13 +4364,13 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .command("db")
         .description("Tenant database commands.")
         .addCommand(new Command("status")
-        .description("Show the current organization's tenant database status. Staff can pass global --org to inspect another org.")
+        .description("Show the current database provider and status. Hosting is included in your plan; Neon IDs on a PostgreSQL row are historical lineage. Staff can pass global --org to inspect another org.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("db status", options, () => requestOxygen("/api/cli/db/status"));
     }))
         .addCommand(new Command("provision")
-        .description("Provision a managed Neon tenant database for the current organization. Staff can pass global --org to repair another org.")
+        .description("Provision the current organization on a registered PostgreSQL shard. Staff can pass global --org to repair another org.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("db provision", options, () => requestOxygen("/api/cli/db/provision", { method: "POST", body: {} }));
@@ -4482,14 +4499,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("cost-policy")
-        .description("Show tenant database cost controls and reconciliation status.")
+        .description("Show the historical Neon cost-policy record. PostgreSQL hosting has no Neon endpoint controls.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("db cost-policy", options, () => requestOxygen("/api/cli/db/cost-policy"));
     }))
         .addCommand(new Command("reconcile-cost-policy")
-        .description("Apply tenant database cost controls to the managed Neon endpoint.")
-        .option("--suspend-idle", "Request immediate Neon compute suspension when the tenant is idle.")
+        .description("Retired compatibility command: report that Neon endpoint controls no longer apply.")
+        .option("--suspend-idle", "Retired compatibility flag; does not suspend PostgreSQL.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("db reconcile-cost-policy", options, () => requestOxygen("/api/cli/db/reconcile-cost-policy", {
@@ -4729,7 +4746,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("get")
-        .description("Get one scheduled post with resolved media previews, its LinkedIn video cover, and attempt history. For an X post, publish_plan lists every post that will be sent, in order, with media, alt text, poll and reply settings (free); for a LinkedIn post that tags a company page, it shows the text sent, each company tag as its page id. Open web_url to preview the post as it will look on LinkedIn or X.")
+        .description("Get one scheduled post with resolved media previews, its LinkedIn video cover, and attempt history. For an X post, publish_plan lists every post that will be sent, in order, with media, alt text, poll and reply settings (free); for a LinkedIn post that tags a company page, it shows the text sent, each company tag as its page id, once `publishing posts approve` has resolved the tags (before approval it is absent). Open web_url to preview the post as it will look on LinkedIn or X.")
         .argument("<post_id>", "Scheduled post id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {
@@ -6791,7 +6808,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("insert")
-        .description("Insert rows into a workspace table.")
+        .description("Insert rows into a workspace table. Table writes cost 0 Oxygen credits; paid column runs are separate.")
         .argument("<table>", "Table id or slug.")
         .requiredOption("--rows-json <json>", 'JSON array of row objects keyed by column key, e.g. [{"name":"Acme","domain":"acme.test"},{"name":"Globex","domain":"globex.test"}].')
         .option("--request-id <id>", "Stable retry key. Reuse it after a timeout to return the committed write without duplicating rows.")
@@ -7040,7 +7057,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("Describe a workspace table and its columns. Add --stats for row count and per-column fill rates (0 credits). Next: `tools search --for-table <table>` lists what these columns can be enriched with and what each costs per row (0 credits).")
         .argument("<table>", "Table id or slug.")
         .option("--include-archived", "Include archived columns.")
-        .option("--stats", "Include summary stats: exact row count and per-column fill rates. Exact at or under 100 rows; above that fill rates come from a 100-row sample (summary.statsSampled, summary.statsSampledRowCount) while rowCount stays exact. For whole-table fill rates on a bigger list use `tables preview <table> --summary-only` \u2014 exact up to 20,000 rows, 2,000-row sample above. 0 credits.")
+        .option("--stats", "Include stats.rowCount (also summary.rowCount) and per-column fill rates. Row count is exact; above 100 rows fill rates use a 100-row sample (stats.statsSampled). For whole-table fill rates on a bigger list use `tables preview <table> --summary-only` \u2014 exact up to 20,000 rows, 2,000-row sample above. 0 credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
         await handleAsyncAction("tables describe", options, () => requestOxygen("/api/cli/tables/describe", {
@@ -9942,7 +9959,7 @@ Examples:
         });
     }))
         .addCommand(new Command("convert")
-        .description("Convert a column between an AI column and a Web Research Agent column (--to agent or --to ai), or switch an agent to Keyword search and back. Keeps its key, label, position, prompt, inputs and model tier, and clears its results, so it needs --yes; without it this prints what would change.")
+        .description("Convert a column between an AI column and a Web Research Agent column (--to agent or --to ai), or switch an agent to Keyword search and back. Keyword search returns a raw search-result list, not a sourced answer; the saved search question becomes its query. Conversion keeps the key, label and position, clears results, and needs --yes; without it this prints what would change.")
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
         .requiredOption("--to <target>", "agent (Web Research Agent), ai (AI column, no web access) or keyword (Keyword search).")
@@ -10930,6 +10947,7 @@ Examples:
     program
         .command("limits")
         .description("Plan-tier limits, spend-safety defaults, per-channel sending limits, and storage capacity posture.")
+        .addHelpText("after", "\nRun `oxygen limits show --json` to see your current plan's API and webhook rates, Table and workspace storage headroom, and the next scheduled change. The $999 and $1,999 rows-per-Table increases remain held until capacity testing passes.\n")
         .addCommand(new Command("show")
         .description("Compare every plan size: price, monthly credits, volume bonus and price per 100 credits (`plan_bands`). Show your plan band and its limits beside every plan size's (API rate, webhook ingress, storage, import file size, columns per auto-run, signals feed, spend defaults incl. Agent and Copilot caps, fastest workflow schedule), the per-channel sending limits every plan shares (emails per mailbox, WhatsApp, LinkedIn, calls) and its workflow Code-step and run-attempt limits, plus Tables capacity usage naming the largest Table. Each plan size's storage says whether it is in force, scheduled to change on a date, or awaiting its rows-per-Table capacity test, with the values it moves to. `spend_safety_defaults.applies_to` says what each spend default bounds: an unattended trigger delivery, a table auto-run batch, one Agent run, or the attended Copilot. `web_url` opens the same view in the web app (Settings → Plan limits), including any scheduled change. Read-only; spends no credits. Recovery: https://oxygen-agent.com/docs/safety/billing.")
         .option("--json", "Print a JSON envelope.")
@@ -10982,7 +11000,7 @@ Examples:
         .command("billing")
         .description("Plan and managed credit commands. Spend splits into FLEXIBLE (ad-hoc: enrichment, AI, automation — drawn from your free-to-spend balance) and FIXED recurring per-resource monthly commitments blocked out of it; see `billing commitments`. THREE CLOCKS, deliberately different: the CREDIT CYCLE that `billing allowance` reports against (your plan's monthly grant window); each resource's own COMMITMENT RENEWAL, anchored to the day you connected it, so `billing commitments --json` next_due_at rarely matches the cycle end; and your SUBSCRIPTION PERIOD in `billing balance` (annual plans span many credit cycles). A number from one clock will not reconcile against another. On a plan that pays for several workspaces, `billing usage --group-by workspace` totals what each one spent. To price a month of outreach before building it (leads, enrichment, sequence steps, senders), run `billing estimate`. Failed-payment grace, suspension, and recovery: https://oxygen-agent.com/docs/safety/billing.")
         .addCommand(new Command("change")
-        .description("Start a first plan or preview an upgrade, downgrade or billing-interval change, and return the Stripe link to approve it (`approval_url`), with the target plan's monthly credits (`target_plan`). On a workspace with no plan (`mode: first_subscription`) the link is the same Stripe Checkout the web Subscribe button opens, and credits arrive once Stripe confirms the first payment; subscribing needs an organization admin. Nothing is charged or changed until you confirm in Stripe. `interval` is how the plan bills after the change; `recurring_amount` is what each interval bills and `recurring_monthly` its per-month equivalent (a yearly $99 plan: $990, $82.50). Without --interval the plan keeps its current interval. Moving to yearly applies on confirmation with proration; moving to monthly waits for the period end. To compare every plan's credits, volume bonus and price per 100 credits without creating a link, run `limits show`.")
+        .description("Create a Stripe approval link to start a first plan or change an existing plan, and return that link (`approval_url`), with the target plan's monthly credits (`target_plan`). On a workspace with no plan (`mode: first_subscription`) the link is the same Stripe Checkout the web Subscribe button opens, and credits arrive once Stripe confirms the first payment; subscribing needs an organization admin. Nothing is charged or changed until you confirm in Stripe. `interval` is how the plan bills after the change; `recurring_amount` is what each interval bills and `recurring_monthly` its per-month equivalent (a yearly $99 plan: $990, $82.50). Without --interval the plan keeps its current interval. Moving to yearly applies on confirmation with proration; moving to monthly waits for the period end. To compare every plan's credits, volume bonus and price per 100 credits without creating a link, run `limits show`.")
         .requiredOption("--to <plan>", 
     // Derived from the catalog, never retyped: this help text is the only
     // place a customer's agent learns which plans exist, and it named
@@ -11003,7 +11021,7 @@ Examples:
             : "";
         return `${key} ($${cents / 100}/mo${creditText})`;
     }).join(", ")}.`)
-        .option("--interval <interval>", "Bill monthly (`month`) or yearly (`year`: ten months' price for twelve, credits still granted monthly). Omit to keep the current interval (monthly for a first plan). Monthly to yearly adds no extra month: credits already granted for the rest of the month count toward the first yearly month. Yearly is refused with `annual_billing_unavailable` until it is offered.")
+        .option("--interval <interval>", "Bill monthly (`month`) or yearly (`year`: ten months' price for twelve, credits still granted monthly). Omit to keep the current interval (monthly for a first plan). Monthly to yearly adds no extra month: credits already granted for the rest of the month count toward the first yearly month. Check `annual_billing_available` with `oxygen billing balance --json` before creating a Stripe link. Yearly is refused with `annual_billing_unavailable` until it is offered.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing change", options, () => requestOxygen("/api/cli/billing/change", {
@@ -11013,13 +11031,13 @@ Examples:
         }));
     }))
         .addCommand(new Command("balance")
-        .description("Show the current plan, subscription entitlement, and managed credit balance: available and reserved credits, FIXED credits committed to recurring per-resource charges, and the FLEXIBLE free-to-spend remainder. `next_renewal` answers \"will I be charged?\": read `will_charge` first — true only when this workspace's own Stripe plan is going to charge its card, in which case `charge_at` and the plan's monthly list price in money say when and roughly how much (the exact amount, with any promotion code or tax, is on the invoice); `period_ends_at` is the trial or period end either way, `cancellation_scheduled` says whether a cancellation is already set, and `stop_command` names the one command that changes it (`billing cancel`, undone by `billing resume`) or is null when nothing here can stop it (staff-invoiced, billed through another workspace, not active). `billing_interval` says whether the plan bills monthly or yearly; a yearly plan still grants its credits monthly, and `next_credit_grant_at` says when the next monthly grant arrives. `renewals_past_due` lists infrastructure renewals (managed-inbox domains, warm-ups) OXYGEN could NOT charge this month, what they cost, and the exact top-up that clears them — nothing is cancelled and billing retries automatically after a top-up. `warnings` also flags a recurring_shortfall when your connected infrastructure costs more per month than the plan grants. `partner_bonus` says whether this workspace earns the agency partner bonus (+15% credits a month for a published directory partner on $99 or above), how many credits, and why not when it does not; the bonus arrives as its own ledger line (`billing usage --category partner_bonus`), never inside plan.monthly_credits. A workspace linked to another organization (`orgs billing-link`) reads its billing at that owner: the balance is the owner's pool, `shared_billing` is true and `billing_owner_organization_id` names the owner. After failed-payment grace expires, mutations stop while read/export and billing recovery remain available. Recovery: https://oxygen-agent.com/billing. Policy: https://oxygen-agent.com/docs/safety/billing.")
+        .description("Show the current plan, whether yearly billing is offered (`annual_billing_available`), subscription entitlement, and managed credit balance: available and reserved credits, FIXED credits committed to recurring per-resource charges, and the FLEXIBLE free-to-spend remainder. `next_renewal` answers \"will I be charged?\": read `will_charge` first — true only when this workspace's own Stripe plan is going to charge its card, in which case `charge_at` and the plan's monthly list price in money say when and roughly how much (the exact amount, with any promotion code or tax, is on the invoice); `period_ends_at` is the trial or period end either way, `cancellation_scheduled` says whether a cancellation is already set, and `stop_command` names the one command that changes it (`billing cancel`, undone by `billing resume`) or is null when nothing here can stop it (staff-invoiced, billed through another workspace, not active). `billing_interval` says whether the plan bills monthly or yearly; a yearly plan still grants its credits monthly, and `next_credit_grant_at` says when the next monthly grant arrives. `renewals_past_due` lists infrastructure renewals (managed-inbox domains, warm-ups) OXYGEN could NOT charge this month, what they cost, and the exact top-up that clears them — nothing is cancelled and billing retries automatically after a top-up. `warnings` also flags a recurring_shortfall when your connected infrastructure costs more per month than the plan grants. `partner_bonus` says whether this workspace earns the agency partner bonus (+15% credits a month for a published directory partner on $99 or above), how many credits, and why not when it does not; the bonus arrives as its own ledger line (`billing usage --category partner_bonus`), never inside plan.monthly_credits. A workspace linked to another organization (`orgs billing-link`) reads its billing at that owner: the balance is the owner's pool, `shared_billing` is true and `billing_owner_organization_id` names the owner. After failed-payment grace expires, mutations stop while read/export and billing recovery remain available. Recovery: https://oxygen-agent.com/billing. Policy: https://oxygen-agent.com/docs/safety/billing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing balance", options, () => requestOxygen("/api/cli/billing/balance"));
     }))
         .addCommand(new Command("commitments")
-        .description("List the fixed monthly credit commitments blocked at your subscription renewal — per connected sending mailbox, OXYGEN-sold mailbox, warm-up, deliverability, connected LinkedIn, WhatsApp and X account, and rented phone number — with unit price, quantity, and next-due date. When your balance cannot cover an account's renewal, sending from that account pauses at once and it disconnects 7 days later (a phone number is released after 30): paused_quantity, past_due_since, disconnects_at and topup_url say which kind, since when and by when to top up; a top-up resumes it within minutes. This is the FORWARD run-rate: what your currently-connected resources will cost at their next renewal. It is NOT this cycle's charges — compare `billing allowance` fixed_spent_credits for that, and expect the two to differ. Each resource renews on its OWN anchor (the day it was connected), so next_due_at is per-resource and rarely lines up with the credit cycle. Read-only, 0 Oxygen credits.")
+        .description("List the fixed monthly credit commitments blocked at your subscription renewal — per connected sending mailbox, OXYGEN-sold mailbox, warm-up, deliverability, connected LinkedIn, WhatsApp and X account, and rented phone number — with unit price, quantity, and next-due date. When your balance cannot cover an account's renewal, sending from that account pauses at once and it disconnects 7 days later (a phone number is released after 30): paused_quantity, past_due_since, disconnects_at and topup_url say which kind, since when and by when to top up; a top-up resumes it within minutes. This is the FORWARD run-rate: what your currently-connected resources will cost at their next renewal. It is NOT this cycle's charges — compare `billing allowance` fixed_spent_credits for that, and expect the two to differ. Each resource renews on its OWN anchor (the day it was connected), so next_due_at is per-resource and rarely lines up with the credit cycle. The top-level count is the number of individual resource rows; the commitments list groups them by kind. A past next_due_at is an unpaid renewal still due. To stop all infrastructure renewals while retaining records, preview `workspace infrastructure-exit`; plan cancellation alone does not stop these resources. Read-only, 0 Oxygen credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing commitments", options, () => requestOxygen("/api/cli/billing/commitments"));
@@ -11211,7 +11229,7 @@ Examples:
         }));
     }))
         .addCommand(new Command("cancel")
-        .description("Schedule the plan subscription to cancel at period end. Free (no fee, no credits); the plan stays usable until then and the card is not charged again (during a trial, never). Prints the end date; undo any time before then with billing resume.")
+        .description("Schedule the plan subscription to cancel at period end. Free (no fee, no credits); the plan stays usable until then and the card is not charged again (during a trial, never). Separately funded external resources keep renewing; preview `workspace infrastructure-exit` if you want to end those too. Prints the end date; undo any time before then with billing resume.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing cancel", options, () => requestOxygen("/api/cli/billing/cancel", {
@@ -11249,7 +11267,7 @@ Examples:
         .command("budget")
         .description("Standing credit caps (org/table daily/monthly hard-blocks) beyond per-run max_credits.")
         .addCommand(new Command("list")
-        .description("List the organization's standing budget policies, plus the plan defaults that apply without one: the daily spend guard (until you set your own org daily budget) and the per-run ceilings of one Agent run, trigger delivery or auto-run batch. Every spend default: `oxygen limits show`.")
+        .description("Read-only, 0 credits. List standing caps with each policy's current spend and remaining credits, plus plan defaults: the daily spend guard and per-run ceilings of one Agent run, trigger delivery or auto-run batch. Daily/monthly windows start at 00:00 UTC; spend counts reservations minus releases, including open holds. Scoped caps currently measure workspace-wide spend. Every spend default: `oxygen limits show`.")
         .option("--scope <scope>", `Filter by scope: ${formatPublicBudgetScopes()}.`)
         .option("--status <status>", "Filter by status. Defaults to all.")
         .option("--json", "Print a JSON envelope.")
@@ -11265,7 +11283,7 @@ Examples:
         });
     }))
         .addCommand(new Command("set")
-        .description("Set, raise, or lower a standing credit cap (idempotent per scope+window).")
+        .description("Set, raise, or lower a standing credit cap (idempotent per scope+window). Daily/monthly windows start at 00:00 UTC and count reservations minus releases; inspect current use with `oxygen budget list`.")
         .requiredOption("--scope <scope>", formatPublicBudgetScopes())
         .requiredOption("--window <window>", "per_run, daily, or monthly.")
         .requiredOption("--max-credits <credits>", "Cap in Oxygen credits.")
@@ -12106,7 +12124,7 @@ Examples:
         });
     }))
         .addCommand(new Command("triggers")
-        .description("List Workspace Agent cron, internal event, and webhook triggers.")
+        .description("List Workspace Agent cron, internal event, and webhook triggers. A legacy cron held to the plan minimum includes slowed_to_plan_minimum and its next run time.")
         .argument("<slug>", "Currently: workspace.")
         .option("--json", "Print a JSON envelope.")
         .action(async (slug, options) => {
@@ -14519,7 +14537,7 @@ Examples:
         });
     })));
     program.addCommand(new Command("inbox")
-        .description("Unified inbox (unibox): private email + LinkedIn DM + WhatsApp conversations in one stream (the default), or a single channel with --channel; `get` and `send` resolve a conversation's channel from its id. Public comments on owned LinkedIn posts are not inbox messages; use `publishing comments`. Scan, read threads, and reply.")
+        .description("Unified inbox (unibox): private email + LinkedIn DM + WhatsApp conversations in one stream (the default), or a single channel with --channel; `get` and `send` resolve a conversation's channel from its id. Public comments on owned LinkedIn posts are not inbox messages; use `publishing comments`. Scan, read, reply, or start a WhatsApp chat.")
         .addCommand(new Command("list")
         .description("List conversations newest first across email, LinkedIn, and WhatsApp — the merged stream is the default, --channels narrows it, and --channel email/linkedin/whatsapp lists a single channel. Primary excludes the negative tier (not_now, not_interested, lost, bounced); All includes every ordinary conversation. Background AI reply triage sets each conversation's status, so triage is a filter, not a script: `--status interested` is positive sales intent, `--status not_interested` is who said no, and `--unanswered` only means the last message is theirs. None of them means a thread needs a reply: interested includes thank-yous and booking confirmations, and neutral can hold real questions. A reply that just arrived can read neutral until it is analyzed (`inbox analyze <id>` classifies one now). In --json, `count` is the rows on this page (follow next_cursor for more); on email, `total_conversations` and the `sidebar_counts` facets are mailbox-wide and do not apply your filters, so never read them as the size of a filtered list.")
         .option("--channel <channel>", "Inbox channel: all (default, the merged stream), email, linkedin, or whatsapp.")
@@ -14627,13 +14645,58 @@ Examples:
         .option("--channel <channel>", "Optional: email, linkedin, or whatsapp. Resolved from the conversation when omitted.")
         .option("--approved", "Approve and send the message. Without this flag, returns a preview only.")
         .option("--draft-id <id>", "When approving an AI reply-agent draft (email or LinkedIn), its id (marks it sent on success). Use the matching --channel.")
-        .option("--attach <url>", "LinkedIn only: attach a file by public URL (image/document). Repeatable, up to 5.", collectRepeatable, [])
+        .option("--attach <path-or-url>", "Email: local PDF, DOCX, XLSX, PPTX, TXT, or CSV path; preview uploads it for 24 hours without sending. LinkedIn: public URL. Repeatable, up to 5 files and 10 MiB total for email.", collectRepeatable, [])
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("inbox send", options, () => {
-            const channel = readOption(options.channel);
+        await handleAsyncAction("inbox send", options, async () => {
+            let channel = readOption(options.channel);
             const draftId = readOption(options.draftId);
-            const attachments = (options.attach ?? []).map((url) => url.trim()).filter(Boolean).map((url) => ({ url }));
+            const attached = (options.attach ?? []).map((value) => value.trim()).filter(Boolean);
+            if (attached.length > 5)
+                throw new OxygenError("invalid_attachments", "Attach up to five files.", { exitCode: 1 });
+            if (attached.length && !channel) {
+                const detail = await requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}`);
+                channel = readRecordString(detail, "channel");
+            }
+            const attachments = channel === "linkedin" ? attached.map((url) => ({ url })) : [];
+            const attachmentIds = [];
+            if (attached.length && channel === "email") {
+                const { readFile, stat } = await import("node:fs/promises");
+                const { basename } = await import("node:path");
+                const { createHash } = await import("node:crypto");
+                let totalBytes = 0;
+                const base = `/api/cli/inbox/${encodeURIComponent(conversation)}/attachments`;
+                for (const filePath of attached) {
+                    const info = await stat(filePath);
+                    totalBytes += info.size;
+                    if (!info.isFile() || info.size < 1 || totalBytes > 10 * 1024 * 1024) {
+                        throw new OxygenError("attachment_size_invalid", "Email attachments must be files totaling at most 10 MiB.", { exitCode: 1 });
+                    }
+                    const bytes = await readFile(filePath);
+                    const ticket = await requestOxygen(`${base}/upload-url`, {
+                        method: "POST", body: { name: basename(filePath), byte_length: bytes.byteLength,
+                            sha256: createHash("sha256").update(bytes).digest("hex") },
+                    });
+                    const uploadUrl = readRecordString(ticket, "upload_url");
+                    const file = ticket.file;
+                    const fileId = file && typeof file === "object" && !Array.isArray(file)
+                        ? readRecordString(file, "id") : null;
+                    if (!uploadUrl || !fileId)
+                        throw new OxygenError("attachment_upload_failed", "The server did not return a complete upload ticket.", { exitCode: 1 });
+                    const put = await fetch(uploadUrl, { method: "PUT", headers: {
+                            "content-type": readRecordString(ticket, "upload_content_type") ?? "application/octet-stream",
+                        }, body: new Uint8Array(bytes) });
+                    if (!put.ok)
+                        throw new OxygenError("attachment_upload_failed", `Object storage rejected the upload (${put.status}).`, { exitCode: 1 });
+                    await requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/attachments/${encodeURIComponent(fileId)}/uploaded`, {
+                        method: "POST", body: {},
+                    });
+                    attachmentIds.push(fileId);
+                }
+            }
+            else if (attached.length && channel !== "linkedin") {
+                throw new OxygenError("attachments_unsupported", "Files can only be attached to email replies or LinkedIn public URLs.", { exitCode: 1 });
+            }
             return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/send`, {
                 method: "POST",
                 body: {
@@ -14642,9 +14705,27 @@ Examples:
                     ...(options.approved ? { approved: true } : {}),
                     ...(draftId ? { draft_id: draftId } : {}),
                     ...(attachments.length > 0 ? { attachments } : {}),
+                    ...(attachmentIds.length > 0 ? { attachment_ids: attachmentIds } : {}),
                 },
             });
         });
+    }))
+        .addCommand(new Command("start-whatsapp")
+        .description("Start a one-to-one WhatsApp chat from the Unibox. Choose a connected sender and either a phone with country code or a CRM person row id. Without --approved, preview the exact recipient and first message. Cold chats use an unofficial linked-device connection and can increase account restriction risk.")
+        .requiredOption("--sender <id>", "Connected WhatsApp sender account id.")
+        .option("--phone <number>", "Recipient phone with country code, e.g. +14155550142.")
+        .option("--person-row-id <id>", "CRM people record row id; uses that person's phone.")
+        .requiredOption("--text <message>", "First message to send.")
+        .option("--approved", "Approve and send the WhatsApp message. Without this flag, returns a preview.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("inbox start-whatsapp", options, () => requestOxygen("/api/cli/inbox/whatsapp/start", {
+            method: "POST",
+            body: { sender_account_id: readOption(options.sender),
+                ...(options.phone ? { phone: readOption(options.phone) } : {}),
+                ...(options.personRowId ? { person_row_id: readOption(options.personRowId) } : {}),
+                text: readOption(options.text), ...(options.approved ? { approved: true } : {}) },
+        }));
     }))
         .addCommand(new Command("delete-message")
         .description("Delete your sent LinkedIn message for everyone within 60 minutes. This cannot be undone. Omit --approved for a preview; show it before approving. Other channels and inbound messages are unsupported.")
@@ -14683,7 +14764,7 @@ Examples:
         .option("--domain <domains>", "Email only: comma-separated counterpart domains to include.")
         .option("--exclude-domain <domains>", "Email only: comma-separated counterpart domains to exclude.")
         .option("--mailbox-id <ids>", "Email only: comma-separated mailbox ids.")
-        .option("--sender-account-id <ids>", "DMs only: comma-separated LinkedIn/WhatsApp sender account ids.")
+        .option("--sender-account-id <ids>", "DMs only: comma-separated OXYGEN sender UUIDs from `oxygen senders list --json` (not LinkedIn member ids).")
         .option("--since <iso>", "Only conversations whose last message is on/after this ISO date/timestamp. Cross-channel.")
         .option("--until <iso>", "Only conversations whose last message is on/before this ISO date/timestamp. Cross-channel.")
         .option("--search <text>", "Fuzzy search (typos, word order, prefixes) over names, addresses, subjects and the text of every message in EVERY non-warmup conversation: all channels unless --channel narrows, archived and sent-only threads included. --segment, --unanswered and the Primary tab's negative-tier exclusion are ignored while set; explicit facets such as --status still narrow.")
@@ -15193,7 +15274,7 @@ Examples:
         });
     })));
     program.addCommand(new Command("sequences")
-        .description("Multichannel outreach sequences: one enrollment per lead can span LinkedIn, email, WhatsApp, human call tasks, and connected-CRM tasks. LinkedIn steps dispatch natively (rate-limited, credit-capped); email steps send natively or place/move/stop the lead in a bound Instantly campaign (BYOK); crm_task can exact-match/upsert/link CRM records and create a mapped external follow-up (HubSpot first), with replay-safe per-operation receipts. Cross-channel reply-stop is intrinsic.")
+        .description("Multichannel outreach sequences: one enrollment per lead can span LinkedIn, email, WhatsApp, human call tasks, and connected-CRM tasks. LinkedIn steps dispatch natively (rate-limited, credit-capped); email steps send natively or place/move/stop the lead in a bound Instantly campaign (BYOK); crm_task can exact-match/upsert/link CRM records and create a mapped external follow-up (HubSpot first), with replay-safe per-operation receipts. A reply always stops that lead, on every channel. To also pause the replier's colleagues, set `--company-reply-pause` on `create`/`update` (pick the reply categories); to pause or resume a company by hand or from a workflow (e.g. a meeting was booked), use `pause-company` / `resume-company` / `paused-companies`. A pause is resumable; a company do-not-contact entry (`suppressions`) is a permanent block.")
         .addCommand(new Command("list")
         .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, blocked, degraded, drained, or empty work without SQL. --stats joins each row's LIFETIME funnel.")
         .option("--status <status>", "Filter by status: draft, active, paused, or archived.")
@@ -15468,6 +15549,7 @@ Examples:
     }))
         .addCommand(new Command("create")
         .description("Create a draft multichannel sequence from a steps JSON file. Supports LinkedIn, email, WhatsApp, human call_task, and connected-CRM crm_task journeys. Assign LinkedIn senders with --senders (optional at create — a draft can sit senderless, but enroll/start require at least one for LinkedIn journeys). Native email sends through connected Google/Microsoft mailboxes, including Microsoft SMTP transport; optional --email-* flags bind an Instantly campaign. Install/read the oxygen-sequencer skill for complete mapped CRM task examples.")
+        .addHelpText("after", "\nSenders: each new lead gets one of the --sender-profiles people, 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_mailbox_id sends that email from one exact inbox; 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.\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. Native email sends (email_send) also expose three reserved sender variables from the sending mailbox: {{sender_name}} (mailbox display name), {{sender_first_name}} (its first word), and {{sender_email}} (the from address); a row column of the same name WINS on collision, and a missing display 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 data leaf { has_column: \"email\" } is true when that row_values column has a non-empty value (add present:false for \"missing\") — e.g. route leads that have an email down an email arm and the rest down a LinkedIn arm. 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. 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, install/read the oxygen-sequencer skill.")
@@ -15503,7 +15585,8 @@ Examples:
         .option("--no-stop-on-bounce", "Keep a lead's enrollment running after a hard bounce (default: stop it). The bounce is still recorded as an email_bounced signal either way.")
         .option("--exclude-contacted", "Default every enroll into this sequence to cross-campaign exclusion — skip leads any OTHER active sequence is already contacting. A per-enroll `sequences enroll --exclude-contacted` / `--no-exclude-contacted` always overrides this default. Off by default.")
         .option("--no-exclude-contacted", "Turn the sequence-level exclude-contacted default back OFF (enrollments then exclude cross-campaign only when a call opts in).")
-        .option("--stop-on-reply-scope <scope>", "Native-email reply stop: 'lead' (default) stops the replying enrollment; 'company_domain' also stops active enrollments at the same non-freemail company domain.")
+        .option("--company-reply-pause <off|default|statuses>", "Pause the replier's company in this campaign when a reply has one of these statuses. Oxygen detects the company from work-email domains or explicit company fields; with no company identity, only the replier stops. New sequences start with this setting off. 'default' = interested,neutral,not_now,not_interested; or comma-separated Inbox status keys (`inbox labels list`); 'off' disables it. Read the saved setting with `sequences get`.")
+        .option("--stop-on-reply-scope <scope>", "(deprecated: use --company-reply-pause) 'company_domain' = --company-reply-pause interested,neutral,not_now,not_interested,wrong_person; 'lead' = off.")
         .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("--include-unsubscribe-headers", "Opt in to one-click unsubscribe headers (default off); visible link is separate.")
         .option("--no-include-unsubscribe-headers", "Omit one-click headers.")
@@ -15587,6 +15670,7 @@ Examples:
     }))
         .addCommand(new Command("update")
         .description("Update a sequence. Journey structure/channels/email binding are draft-only so revised scope receives a fresh launch approval; a started sequence may only re-time waits it already has (clear a delay by zeroing it, never by deleting the step — enrollments track position by index); sender pools can change while draft or paused; launch caps change through `sequences start` after first start. Name, throttles, tags, the default-off visible unsubscribe footer, and open/click tracking toggles remain editable as allowed by the server. Pass only the fields you want to change.")
+        .addHelpText("after", "\nSenders: email_send.sender_mailbox_id sends one email from an exact inbox of a selected sender; a LinkedIn step's sender_profile_id sends it from a selected person (invite, message, inmail and withdraw_invite share one or none). Omit both to use the lead's assigned person. An email whose From changes needs its own subject_template.\n")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--name <name>", "New human-readable sequence name.")
         .option("--steps-file <path>", "Draft only: path to a JSON file: { \"steps\": [...] } replacing the journey. Copy supports {{column}} interpolation; native email steps also expose {{sender_name}} / {{sender_first_name}} / {{sender_email}} from the sending mailbox (a same-named row column wins). A `branch` can also route on the lead's data with a data leaf { has_column: \"email\" } (true when that row_values column is non-empty; present:false for \"missing\").")
@@ -15622,7 +15706,8 @@ Examples:
         .option("--no-stop-on-bounce", "Keep a lead's enrollment running after a hard bounce (default: stop it). The bounce is still recorded as an email_bounced signal either way.")
         .option("--exclude-contacted", "Default every enroll into this sequence to cross-campaign exclusion — skip leads any OTHER active sequence is already contacting. A per-enroll `sequences enroll --exclude-contacted` / `--no-exclude-contacted` always overrides this default. Off by default.")
         .option("--no-exclude-contacted", "Turn the sequence-level exclude-contacted default back OFF (enrollments then exclude cross-campaign only when a call opts in).")
-        .option("--stop-on-reply-scope <scope>", "Native-email reply stop: 'lead' (default) stops the replying enrollment; 'company_domain' also stops active enrollments at the same non-freemail company domain.")
+        .option("--company-reply-pause <off|default|statuses>", "Pause the replier's company in this campaign when a reply has one of these statuses. Oxygen detects the company from work-email domains or explicit company fields; with no company identity, only the replier stops. New sequences start with this setting off. 'default' = interested,neutral,not_now,not_interested; or comma-separated Inbox status keys (`inbox labels list`); 'off' disables it. Read the saved setting with `sequences get`.")
+        .option("--stop-on-reply-scope <scope>", "(deprecated: use --company-reply-pause) 'company_domain' = --company-reply-pause interested,neutral,not_now,not_interested,wrong_person; 'lead' = off.")
         .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("--include-unsubscribe-headers", "Opt in to one-click unsubscribe headers (default off); visible link is separate.")
         .option("--no-include-unsubscribe-headers", "Omit one-click headers.")
@@ -15687,7 +15772,7 @@ Examples:
                     body.email = email;
             }
             if (Object.keys(body).length === 0) {
-                throw new Error("Provide at least one field to update (--name, --steps-file, --source-table, --channels, --senders, --tags, --email-*, --clear-email, --max-credits, --max-live-sends, --max-emails-per-mailbox-per-day, --send-window-file, --linkedin-* schedule, --stop-on-reply-scope, --[no-]include-unsubscribe-link, --no-stop-on-bounce, --[no-]exclude-contacted, or --[no-]tracking-opens / --[no-]tracking-clicks).");
+                throw new Error("Provide at least one field to update (--name, --steps-file, --source-table, --channels, --senders, --tags, --email-*, --clear-email, --max-credits, --max-live-sends, --max-emails-per-mailbox-per-day, --send-window-file, --linkedin-* schedule, --company-reply-pause, --[no-]include-unsubscribe-link, --no-stop-on-bounce, --[no-]exclude-contacted, or --[no-]tracking-opens / --[no-]tracking-clicks).");
             }
             return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}`, {
                 method: "PATCH",
@@ -15940,6 +16025,90 @@ Examples:
                 },
             });
         });
+    }))
+        .addCommand(new Command("pause-company")
+        .description("Pause messaging to a company in your campaigns — e.g. after a meeting is booked — and resume it later. Holds every lead of that company (work-email domain, company domain, or LinkedIn company page) in every campaign, or only the --sequence ones; nothing is sent to them until `sequences resume-company`. --dry-run previews the leads it would hold.")
+        .option("--domain <domain>", "The company's domain, e.g. acme.com.")
+        .option("--email <email>", "Any work email at the company; its domain names the company (personal mail hosts such as gmail.com are refused).")
+        .option("--linkedin-company <url>", "The company's LinkedIn page, e.g. https://www.linkedin.com/company/acme.")
+        .option("--record <id>", "A CRM record id: a company; a person (their work-email domain and every linked company); or any record linked to companies, such as a deal.")
+        .option("--sequence <id>", "Pause only in this campaign (id or slug). Repeat for several; omit to pause in every campaign.", collectRepeatable, [])
+        .option("--note <text>", "Why it is paused, shown with the pause (max 500 characters).")
+        .option("--dry-run", "Preview the campaigns and leads that would be held; change nothing.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("sequences pause-company", options, async () => {
+            const sequenceIds = readRepeatableIds(options.sequence);
+            const note = readOption(options.note);
+            const data = await requestOxygen("/api/cli/sequences/company-pauses", {
+                method: "POST",
+                body: {
+                    ...readCompanyIdentityOptions(options, "pause"),
+                    ...(sequenceIds.length > 0 ? { sequence_ids: sequenceIds } : {}),
+                    ...(note ? { note } : {}),
+                    ...(options.dryRun ? { dry_run: true } : {}),
+                },
+            });
+            if (!options.json)
+                writeCompanyPauseSummary(data);
+            return data;
+        });
+    }))
+        .addCommand(new Command("resume-company")
+        .description("Resume messaging to a paused company: its held leads continue where they stopped (due steps are spread over the next hour, waits keep their remaining time). Name one pause with --hold, or the company with one identity flag; --sequence narrows the resume to those campaigns.")
+        .option("--hold <id>", "The pause to resume (`id` from `sequences paused-companies`).")
+        .option("--domain <domain>", "The company's domain, e.g. acme.com.")
+        .option("--email <email>", "Any work email at the company.")
+        .option("--linkedin-company <url>", "The company's LinkedIn page URL.")
+        .option("--record <id>", "A CRM company, person or deal record id.")
+        .option("--sequence <id>", "Resume only in this campaign (id or slug). Repeatable.", collectRepeatable, [])
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("sequences resume-company", options, async () => {
+            const hold = readOption(options.hold);
+            if (hold && countCompanyIdentityOptions(options) > 0) {
+                throw new OxygenError("company_identity_ambiguous", "Name the pause with --hold, or the company with one of --domain, --email, --linkedin-company, or --record — not both.", { exitCode: 2 });
+            }
+            const sequenceIds = readRepeatableIds(options.sequence);
+            const data = await requestOxygen("/api/cli/sequences/company-pauses/resume", {
+                method: "POST",
+                body: {
+                    ...(hold ? { hold_id: hold } : readCompanyIdentityOptions(options, "resume")),
+                    ...(sequenceIds.length > 0 ? { sequence_ids: sequenceIds } : {}),
+                },
+            });
+            if (!options.json)
+                writeCompanyPauseSummary(data);
+            return data;
+        });
+    }))
+        .addCommand(new Command("paused-companies")
+        .description("List the companies paused in your campaigns — by a reply (waiting for its classification, or classified into a paused status) or by hand/automation — with the leads each one holds.")
+        .option("--sequence <id>", "Only pauses in this campaign (id or slug).")
+        .option("--all", "Include resumed/released pauses (history).")
+        .option("--limit <n>", "Maximum pauses to return (1-500, default 100).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("sequences paused-companies", options, async () => {
+            const params = new URLSearchParams();
+            const sequence = readOption(options.sequence);
+            if (sequence)
+                params.set("sequence_id", sequence);
+            if (options.all)
+                params.set("include_released", "true");
+            const limitRaw = readOption(options.limit);
+            if (limitRaw !== null) {
+                const limit = readPositiveInt(limitRaw);
+                if (limit === undefined || limit > 500)
+                    throw new Error("--limit must be between 1 and 500.");
+                params.set("limit", String(limit));
+            }
+            const suffix = params.toString();
+            const data = await requestOxygen(`/api/cli/sequences/company-pauses${suffix ? `?${suffix}` : ""}`);
+            if (!options.json)
+                writeCompanyPauseSummary(data);
+            return data;
+        });
     }))
         .addCommand(new Command("reconcile")
         .description("Safely reconcile one ambiguous LinkedIn invite/message from provider reads. Preview-only unless --approved; never resends.")
@@ -16620,7 +16789,7 @@ Examples:
         }
     }))
         .addCommand(new Command("import-identities")
-        .description("Import a source-neutral typed JSON array into DNC. Kinds: email, phone, linkedin_person, company_domain, linkedin_company. Preferred for integrations; company identities apply across every Sequence channel and are never inferred from a person's email.")
+        .description("Import a source-neutral typed JSON array into DNC. Kinds: email, phone, linkedin_person, company_domain, linkedin_company. Preferred for integrations; company identities apply across every Sequence channel and are never inferred from a person's email. A company entry is a permanent block on every campaign; to pause a company and resume it later, use `sequences pause-company`.")
         .requiredOption("--file <path>", "JSON file containing [{kind,value,reason?,source?,detail?,metadata?}], max 5000.")
         .option("--reason <reason>", "Default reason for entries that omit one.")
         .option("--source <text>", "Default provenance for entries that omit one.")
@@ -17111,7 +17280,7 @@ Examples:
         });
     }))
         .addCommand(new Command("exit")
-        .description("Leave OXYGEN with a managed domain INTACT: stop every OXYGEN renewal for it (inboxes, warm-up, inbox placement) at the end of the period already paid for, keep the domain, mailboxes, DNS, warm-up state and data exactly as they are, and record a handoff request. Nothing is cancelled, disconnected, or released — for that use `managed-inboxes cancel`. WITHOUT --approved prints the plan: each renewal line with the date it stops, what stays, and the vendor-carry note (OXYGEN keeps paying the inbox vendor for these mailboxes after that date until a human completes the handoff or you cancel). To record it, re-run with --approved AND --confirm <domain> echoing the domain exactly. The Google Workspace / registrar handoff itself is coordinated by a human with the vendor — this command records the request, it does not perform the transfer. --revoke resumes renewals on a domain whose exit was requested. Free, 0 Oxygen credits; re-running on an already-exited domain changes nothing (effect_outcome no_change).")
+        .description("Transfer ONE managed domain out of OXYGEN: stop every OXYGEN renewal for this domain after the paid period; keep the domain, mailboxes, DNS, warm-up state and data exactly as they are. Nothing is cancelled, disconnected, or released; the handoff is coordinated by a human with the vendor. OXYGEN continues paying the inbox vendor until that handoff or `managed-inboxes cancel`; the customer does not pay that vendor-carry cost. For all external resources in a workspace, preview `workspace infrastructure-exit` instead. WITHOUT --approved prints the domain plan; to record the transfer, re-run with --approved AND --confirm <domain>. --revoke resumes OXYGEN renewals. Free, 0 credits.")
         .argument("[domain]", "The managed domain to stop renewing. May also be passed as --domain.")
         .option("--domain <domain>", "The managed inbox domain (alternative to the positional argument).")
         .option("--contact <email>", "Who the human handoff should be coordinated with (recorded on the request).")
@@ -17504,7 +17673,7 @@ Examples:
         });
     }))
         .addCommand(new Command("connect-oauth")
-        .description("Connect Google/Microsoft mailboxes to OXYGEN native send. Preview by default; pass --approved only after reviewing exact candidates. --vendor oxygen requires an exact address list and never discovers a domain directory. Microsoft supports --authorization-mode tenant (one administrator approval, up to 500 exact selected addresses, recommended for dedicated sending tenants) or individual (one account sign-in per mailbox, max 10 per run, recommended for ordinary company/personal mailboxes). For Microsoft's built-in roles, tenant mode requires a Global Administrator or Privileged Role Administrator because it requests the Microsoft Graph application Mail.Send and Mail.Read permissions; Application Administrator and Cloud Application Administrator cannot consent to Microsoft Graph application roles. Microsoft's application grant is tenant-wide at the provider; OXYGEN—not Microsoft—enforces the selected-address boundary at verification and send time unless the tenant separately configures Exchange Application RBAC. For non-managed Microsoft mailboxes, native-send approval does not authorize OXYGEN Warm-up: every mailbox still needs its own `mailboxes warmup microsoft` Outlook consent before standalone enrollment. Connecting authorization does not change whether a mailbox is active or disabled. Google uses individual OAuth. Source tokens, passwords, authenticator seeds, and one-time codes never transfer. Managed authorization paths remain available through their vendor options. All paths cost 0 Oxygen credits.")
+        .description("Connect Google/Microsoft mailboxes to OXYGEN native send. Authorization costs 0 credits; once connected, each own mailbox reserves 100 credits per month when the repricing credit commitments are active, including warm-up. Preview by default; pass --approved only after reviewing exact candidates. --vendor oxygen requires an exact address list and never discovers a domain directory. Microsoft supports --authorization-mode tenant (one administrator approval, up to 500 exact selected addresses, recommended for dedicated sending tenants) or individual (one account sign-in per mailbox, max 10 per run, recommended for ordinary company/personal mailboxes). For Microsoft's built-in roles, tenant mode requires a Global Administrator or Privileged Role Administrator because it requests the Microsoft Graph application Mail.Send and Mail.Read permissions; Application Administrator and Cloud Application Administrator cannot consent to Microsoft Graph application roles. Microsoft's application grant is tenant-wide at the provider; OXYGEN—not Microsoft—enforces the selected-address boundary at verification and send time unless the tenant separately configures Exchange Application RBAC. For non-managed Microsoft mailboxes, native-send approval does not authorize OXYGEN Warm-up: every mailbox still needs its own `mailboxes warmup microsoft` Outlook consent before standalone enrollment. Connecting authorization does not change whether a mailbox is active or disabled. Google uses individual OAuth. Source tokens, passwords, authenticator seeds, and one-time codes never transfer. Managed authorization paths remain available through their vendor options.")
         .addHelpText("after", "\nDocs: https://oxygen-agent.com/docs/providers/mailboxes\n")
         .option("--provider <provider>", "Mailbox provider to provision: google or microsoft.")
         .option("--vendor <vendor>", "Authorization path: oxygen for imported/manual mailboxes, zapmail (default), or inboxkit.")
@@ -17688,7 +17857,7 @@ Examples:
         });
     }))
         .addCommand(new Command("warmup")
-        .description("OXYGEN Warm-up for the sending pool — the weeks of low-volume conversational mail that make a new inbox look trusted before you cold-send from it. It costs 100 credits per warming inbox per month ($1), or nothing once it is included in your own mailbox's 100-credit monthly connection (2026-09 repricing); the preview shows which applies. Fresh managed InboxKit Google/Microsoft/Azure orders with the default-on warm-up add-on activate automatically after provisioning under the approved order quote; do not run a second `warmup enable`. Google reuses the InboxKit-held credential only during activation and never stores or returns it; Microsoft/Azure uses exact native export. Standalone preview → approval is for BYOK/imported mailboxes, a managed opt-out, or later separate enrollment. InboxKit auto-export stays off for Microsoft/Azure because Oxygen submits only the exact authorized UIDs, and any non-cancelled InboxKit warm-up blocks either handoff so one mailbox cannot warm twice. OXYGEN Warm-up never owns campaign dispatch: native OXYGEN Sequences still own campaigns and sends. Eligible non-InboxKit Microsoft mailboxes use the separate `mailboxes warmup microsoft` OAuth fallback. Inboxes already warming on the retired TrulyInbox rail keep reporting and are wound down there with `warmup disable`; they are never silently moved to the current managed rail.")
+        .description("OXYGEN Warm-up for the sending pool — the weeks of low-volume conversational mail that make a new inbox look trusted before you cold-send from it. It costs 100 credits per warming inbox per month ($1), or nothing once it is included in your own mailbox's 100-credit monthly connection (2026-09 repricing); the preview shows which applies. Fresh managed InboxKit Google/Microsoft/Azure orders with the default-on warm-up add-on activate automatically after provisioning under the approved order quote; do not run a second `warmup enable`. Google reuses the InboxKit-held credential only during activation and never stores or returns it; Microsoft/Azure uses exact native export. Standalone preview → approval is for BYOK/imported mailboxes, a managed opt-out, or later separate enrollment. InboxKit auto-export stays off for Microsoft/Azure because Oxygen submits only the exact authorized UIDs, and any non-cancelled InboxKit warm-up blocks either handoff so one mailbox cannot warm twice. OXYGEN Warm-up never owns campaign dispatch: native OXYGEN Sequences still own campaigns and sends. Eligible non-InboxKit Microsoft mailboxes use the separate `mailboxes warmup microsoft` OAuth fallback. Inboxes already warming on the retired TrulyInbox rail keep reporting and are wound down there with `warmup disable`; they are never silently moved to the current managed rail. When worker recovery is enforcing (the unset default), existing active paid OXYGEN Warm-up seats get bounded automatic recovery: Google uses usable stored credential authority, Microsoft OAuth or tenant-consent seats get a credential-free vendor reactivation, and stalled dispatch or DNS readiness is rechecked. An explicit shadow/off rollout observes candidates without automatic repair writes. Correct bad DNS records yourself; an active unpaused paid seat needs no manual resume after that correction. OXYGEN never invents consent, resumes a human or safety pause, starts a new paid enrollment, or blindly repeats an ambiguous provider write. Check `warmup status` and `mailboxes list` for the exact next action.")
         .addHelpText("after", "\nDocs: https://oxygen-agent.com/docs/providers/mailboxes\n")
         .addCommand(new Command("enable")
         .description("Optional provider warm-up defaults to 1/day, +1/day, max 10/day (dedicated-tenant profiles stay stricter); see `mailboxes warmup config` for the effective plan and unsupported OXYGEN Warm-up reply-rate control. This is separate from the 5/10/20 campaign ramp. STANDALONE ENROLLMENT: enroll BYOK/imported mailboxes, a managed order that opted out, or mailboxes being added to warmup later. Fresh managed InboxKit Google/Microsoft/Azure orders whose approved quote included warmup activate automatically after provisioning and do not need this command. Targets the whole pool unless --mailboxes is given; one synchronous preview/approval is capped at 220 mailboxes, so split larger pools into explicit batches. Without --approved this is a 0-credit, no-provider-write priced preview: nothing is handed off, enrolled, or billed. The price is 100 credits per warming mailbox-month, or 0 once warm-up is included in the mailbox's 100-credit monthly connection (2026-09 repricing; the preview's included_in_connection says which, and its max_credits is then 0); the preview returns the exact first-cycle ceiling. Preview one inbox with `oxygen mailboxes warmup enable --mailboxes sender@example.com --json`. Execute by echoing its --plan and --max-credits with --approved. Eligible managed Google targets use the InboxKit-held credential just in time without storing or returning it; Microsoft/Azure targets use native InboxKit Sequencer export with exact UIDs and auto-export off. Any non-cancelled InboxKit warmup must be cancelled before either handoff (pausing is not enough). Only eligible non-InboxKit Microsoft mailboxes need `mailboxes warmup microsoft`. OXYGEN Warm-up retains no campaign authority — OXYGEN Sequences own enrollment and dispatch. New enrollments only ever land on the managed OXYGEN rail; the retired TrulyInbox rail is refused here and only accepts teardown.")
@@ -17906,7 +18075,7 @@ Examples:
         });
     }))
         .addCommand(new Command("reconnect")
-        .description("Push the mailbox's CURRENT credential to its warmup provider, for an inbox that is already enrolled. This is how you recover a warmup enrollment whose app password was rotated or revoked (the provider reporting 'Username and Password not accepted'): re-import the new credential with `mailboxes import`, then run this. It costs 0 credits and leaves your warmup subscription and its renewal date exactly as they are — you do NOT need to disable and re-enable warmup, which would charge a second month. The provider cannot change a stored password in place, so the inbox's warmup history restarts from day 1. Targets the whole pool unless --mailboxes is given.")
+        .description("Manual repair for an existing live paid seat when worker recovery is shadow/off, exhausted, or needs a new credential: push the mailbox's CURRENT credential to its warmup provider. Use this when a new app password is needed because the old one was rotated or revoked (the provider reporting 'Username and Password not accepted'): re-import the new credential with `mailboxes import`, then run this. It costs 0 credits and leaves your warmup subscription and its renewal date exactly as they are — you do NOT need to disable and re-enable warmup, which would charge a second month. The provider cannot change a stored password in place, so the inbox's warmup history restarts from day 1. Targets the whole pool unless --mailboxes is given.")
         .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses. Omit for the whole pool.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -17921,7 +18090,7 @@ Examples:
         });
     }))
         .addCommand(new Command("reactivate")
-        .description("Make the warm-up provider re-run the connection check it abandoned on an inbox it has DISABLED, without touching your credential, your subscription, or the ramp day. Use this when warmup status reports an inbox stopped by the provider and `warmup reconnect` refuses it — which is what happens to a Microsoft inbox connected by OAuth or tenant consent, because there is no password to re-push. 0 credits: the subscription, its renewal date, and the ramp day all stay exactly as they are, so it is the free alternative to disable + re-enable (which bills another warm-up month AND restarts the ramp at day 1). Only inboxes with a live warm-up subscription are eligible. IMPORTANT: this forces the provider to re-check; a forced pass is NOT proof the connection works. Confirm recovery from a rising send count with `oxygen mailboxes warmup status` after the provider's next batch, which is hours away, not minutes. Targets the whole pool unless --mailboxes is given.")
+        .description("Manual reactivation of an existing live paid seat: ask the warm-up provider to re-run the connection check on an inbox it has DISABLED, without touching the credential, subscription, or ramp day. When worker recovery is enforcing, OXYGEN first tries this vendor reactivation automatically for a Microsoft OAuth or tenant-consent seat, without a password or new browser consent. Use this command while recovery is staged in shadow/off, or if `warmup status` still asks you to reactivate after bounded attempts; `warmup reconnect` cannot re-push a password for that consent seat. 0 credits: the subscription, its renewal date, and the ramp day all stay exactly as they are, so it is the free alternative to disable + re-enable (which bills another warm-up month AND restarts the ramp at day 1). Only inboxes with a live warm-up subscription are eligible. IMPORTANT: this forces the provider to re-check; a forced pass is NOT proof the connection works. Confirm recovery from a rising send count with `oxygen mailboxes warmup status` after the provider's next batch, which is hours away, not minutes. Targets the whole pool unless --mailboxes is given.")
         .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses. Omit for the whole pool.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -18741,7 +18910,7 @@ Run completion:
         });
     }))
         .addCommand(new Command("get")
-        .description("Get one workflow automation.")
+        .description("Get one workflow automation, including any cron slowdown to your plan's minimum interval.")
         .argument("<workflow>", "Workflow id, slug, or name.")
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
@@ -20886,7 +21055,11 @@ const RESEARCH_MODES = new Set(["strict", "estimate"]);
  */
 function applyResearchColumnConfig(definition, options) {
     const existing = isRecord(definition.webSearch) ? definition.webSearch : {};
-    const webSearch = { ...existing, enabled: true };
+    // Supply the required default only when absent. Preserving an explicit false
+    // lets the server reject it instead of silently turning paid web access on.
+    const webSearch = { ...existing };
+    if (!Object.hasOwn(webSearch, "enabled"))
+        webSearch.enabled = true;
     const queryTemplate = readOption(options.researchQuery);
     if (queryTemplate)
         webSearch.queryTemplate = queryTemplate;
@@ -28798,6 +28971,108 @@ function readNonNegativeNumber(value) {
     }
     return parsed;
 }
+function countCompanyIdentityOptions(options) {
+    return [options.domain, options.email, options.linkedinCompany, options.record]
+        .filter((value) => readOption(value) !== null)
+        .length;
+}
+// Exactly one company identity flag, mapped onto the route's body fields. The
+// server re-checks (and resolves record ids); refusing locally names the flags.
+function readCompanyIdentityOptions(options, verb) {
+    const fields = [
+        ["domain", readOption(options.domain)],
+        ["email", readOption(options.email)],
+        ["linkedin_company_url", readOption(options.linkedinCompany)],
+        ["record_id", readOption(options.record)],
+    ];
+    const provided = fields.filter((entry) => entry[1] !== null);
+    if (provided.length !== 1) {
+        const which = verb === "resume" ? "--hold, or exactly one of " : "exactly one of ";
+        throw new OxygenError(provided.length === 0 ? "company_identity_required" : "company_identity_ambiguous", `Name the company with ${which}--domain, --email, --linkedin-company, or --record.`, { exitCode: 2 });
+    }
+    return Object.fromEntries(provided);
+}
+function readRepeatableIds(values) {
+    return [...new Set((values ?? []).flatMap((value) => readCsvOption(value)))];
+}
+// Human-mode summary of a company pause/resume/list on stderr (stdout keeps the
+// machine-readable envelope): what was held or resumed, per campaign, and where
+// to see it.
+function writeCompanyPauseSummary(data) {
+    const payload = asPayloadRecord(data);
+    if (!payload)
+        return;
+    const lines = [];
+    if (typeof payload.message === "string")
+        lines.push(payload.message);
+    const affected = Array.isArray(payload.affected) ? payload.affected : [];
+    for (const entry of affected) {
+        const record = asPayloadRecord(entry);
+        if (!record)
+            continue;
+        const count = typeof record.enrollments === "number" ? record.enrollments : 0;
+        lines.push(`  ${String(record.sequence_name ?? record.sequence_id)}: ${count} lead${count === 1 ? "" : "s"}`);
+    }
+    // A pause reaching a campaign whose email is sent by Instantly does not stop
+    // those emails; the route says which campaigns, and a human reader must see it.
+    const warnings = Array.isArray(payload.warnings) ? payload.warnings : [];
+    for (const entry of warnings) {
+        const warning = asPayloadRecord(entry);
+        if (warning && typeof warning.message === "string")
+            lines.push(`Warning: ${warning.message}`);
+    }
+    const holds = Array.isArray(payload.holds) && typeof payload.message !== "string" ? payload.holds : [];
+    if (Array.isArray(payload.holds) && typeof payload.message !== "string" && holds.length === 0) {
+        lines.push("No companies are paused.");
+    }
+    for (const entry of holds) {
+        const hold = asPayloadRecord(entry);
+        if (!hold)
+            continue;
+        const scope = typeof hold.sequence_name === "string" ? hold.sequence_name : hold.sequence_id ? String(hold.sequence_id) : "every campaign";
+        const held = typeof hold.held_enrollments === "number" ? hold.held_enrollments : 0;
+        lines.push(`  ${String(hold.display_name)} — ${scope} — ${String(hold.state)} — ${held} lead${held === 1 ? "" : "s"} held (hold ${String(hold.id)})`);
+    }
+    if (typeof payload.next_step === "string")
+        lines.push(payload.next_step);
+    if (typeof payload.web_url === "string")
+        lines.push(`Open: ${payload.web_url}`);
+    if (lines.length > 0)
+        process.stderr.write(`${lines.join("\n")}\n`);
+}
+// `--company-reply-pause` (and its deprecated alias `--stop-on-reply-scope`) as
+// the `settings.company_reply_pause` object the server stores. `default` names
+// the statuses a new campaign gets; the alias maps `company_domain` to exactly
+// what the legacy scope always stopped on and `lead` to off, so an old script
+// keeps its behavior while the server stores one key.
+function readCompanyReplyPauseOption(value, legacyScope) {
+    const raw = readOption(value);
+    const legacy = readOption(legacyScope);
+    if (raw && legacy) {
+        throw new OxygenError("invalid_company_reply_pause", "Pass --company-reply-pause only; --stop-on-reply-scope is its deprecated alias.", { exitCode: 2 });
+    }
+    if (legacy) {
+        if (legacy === "company_domain")
+            return { enabled: true, statuses: [...COMPANY_REPLY_PAUSE_LEGACY_STATUSES] };
+        if (legacy === "lead")
+            return { enabled: false, statuses: [] };
+        throw new OxygenError("invalid_company_reply_pause", "--stop-on-reply-scope must be lead or company_domain (deprecated: use --company-reply-pause).", { details: { value: legacy }, exitCode: 2 });
+    }
+    if (!raw)
+        return undefined;
+    const normalized = raw.toLowerCase();
+    if (normalized === "off")
+        return { enabled: false, statuses: [] };
+    if (normalized === "default" || normalized === "on") {
+        return { enabled: true, statuses: [...COMPANY_REPLY_PAUSE_DEFAULT_STATUSES] };
+    }
+    const statuses = [...new Set(readCsvOption(normalized))];
+    const invalid = statuses.filter((status) => !COMPANY_REPLY_PAUSE_STATUS_KEY_PATTERN.test(status));
+    if (statuses.length === 0 || invalid.length > 0) {
+        throw new OxygenError("invalid_company_reply_pause", "--company-reply-pause takes off, default, or comma-separated Inbox status keys such as interested,not_now.", { details: { invalid }, exitCode: 2 });
+    }
+    return { enabled: true, statuses };
+}
 // Folds the sequence-level email send controls (--max-emails-per-mailbox-per-day,
 // --send-window-file) into a partial `settings` object. Returns undefined when
 // neither flag is set so the field is omitted from the request body entirely.
@@ -28853,9 +29128,9 @@ function readSequenceSettings(options) {
     if (options.includeUnsubscribeLink !== undefined) {
         settings.include_unsubscribe_link = options.includeUnsubscribeLink;
     }
-    const stopOnReplyScope = readOption(options.stopOnReplyScope);
-    if (stopOnReplyScope)
-        settings.stop_on_reply_scope = stopOnReplyScope;
+    const companyReplyPause = readCompanyReplyPauseOption(options.companyReplyPause, options.stopOnReplyScope);
+    if (companyReplyPause)
+        settings.company_reply_pause = companyReplyPause;
     const maxEmailsPerDay = readPositiveInt(options.maxEmailsPerDay);
     if (maxEmailsPerDay !== undefined)
         settings.max_emails_per_day = maxEmailsPerDay;