npm - @oxygen-agent/cli - Versions diffs - 1.152.15 → 1.160.18 - Mend

@oxygen-agent/cli 1.152.15 → 1.160.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/README.md +2 -2
package/dist/index.js +841 -127
package/dist/transcript.d.ts +21 -0
package/dist/transcript.js +208 -0
package/node_modules/@oxygen/shared/dist/index.d.ts +2 -0
package/node_modules/@oxygen/shared/dist/index.js +2 -0
package/node_modules/@oxygen/shared/dist/linkedin-sequences.d.ts +54 -31
package/node_modules/@oxygen/shared/dist/linkedin-sequences.js +15 -219
package/node_modules/@oxygen/shared/dist/log.js +12 -4
package/node_modules/@oxygen/shared/dist/sequences.d.ts +238 -0
package/node_modules/@oxygen/shared/dist/sequences.js +501 -0
package/node_modules/@oxygen/shared/dist/sql-error.d.ts +43 -0
package/node_modules/@oxygen/shared/dist/sql-error.js +318 -0
package/node_modules/@oxygen/shared/dist/telemetry.js +26 -3
package/node_modules/@oxygen/shared/dist/version.d.ts +2 -2
package/node_modules/@oxygen/shared/dist/version.js +5 -2
package/node_modules/@oxygen/workflows/dist/index.d.ts +0 -19
package/node_modules/@oxygen/workflows/dist/index.js +16 -19
package/package.json +1 -1

package/dist/index.js CHANGED Viewed

@@ -10,13 +10,14 @@ import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { Command, Option } from "commander";
 import { formatCellForDisplay, OXYGEN_VERSION, OxygenError, success, toFailure } from "@oxygen/shared";
-import { inferRowsFileFormat, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, } from "@oxygen/shared/file-import";
+import { inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, } from "@oxygen/shared/file-import";
 import { assertRecipeBundleSafe, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowManifest, } from "@oxygen/workflows";
 import { isRecipeDefinition } from "@oxygen/recipe-sdk";
 import { createBrowserLoginSession, openBrowser } from "./browser-login.js";
 import { clearCredentials, defaultApiUrl, listCredentialProfiles, normalizeApiUrl, pickProfileNameForIdentity, pickProfileNameForUserSession, resolveActiveProfile, saveCredentials, switchCredentialProfile, updateActiveOrganizationForProfile, } from "./credentials.js";
 import { ensureFreshCliForApiUrl, requestOxygen } from "./http-client.js";
 import { runLocalCustomHttpColumn } from "./local-custom-http-column.js";
+import { captureCurrentTranscript, collectFeedbackEnvironment, TranscriptCaptureError, } from "./transcript.js";
 import { addSessionOutput, addSessionStatus, getSessionUsage, startSession, updateSessionStep, } from "./session.js";
 import { doctorAgentSkills, installAgentSkills, listAgentSkills, runAutomaticSkillsInstall, } from "./skills.js";
 import { resolveCliBinaryName } from "./runtime.js";
@@ -426,6 +427,100 @@ export function createProgram() {
             },
         }));
     }));
+    program
+        .command("support")
+        .description("File and track Oxygen support tickets.")
+        .addCommand(new Command("file")
+        .description("File a support ticket. Use when you're stuck on an Oxygen operation.")
+        .requiredOption("--subject <subject>", "One-line summary of the problem.")
+        .option("--body <body>", "What you were doing, what happened, and what you tried.")
+        .option("--severity <severity>", "low | normal | high. Defaults to normal.")
+        .option("--category <category>", "Optional category label.")
+        .option("--operation <operation>", "The operation/tool that failed, e.g. oxygen_columns_run.")
+        .option("--error-code <code>", "The error envelope code you received.")
+        .option("--run-ids <ids>", "Comma-separated run ids to attach.")
+        .option("--table-ids <ids>", "Comma-separated table ids to attach.")
+        .option("--deep-links <urls>", "Comma-separated https://oxygen-agent.com/... links.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("support ticket create", options, () => requestOxygen("/api/cli/support/tickets", {
+            method: "POST",
+            body: buildSupportTicketBody(options),
+        }));
+    }))
+        .addCommand(new Command("list")
+        .description("List support tickets for the active organization.")
+        .option("--status <status>", "Filter by status (open, triaging, waiting_on_user, resolved, closed).")
+        .option("--limit <n>", "Max tickets to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("support tickets list", options, () => requestOxygen(withSupportListQuery("/api/cli/support/tickets", options)));
+    }))
+        .addCommand(new Command("get")
+        .description("Show one support ticket with its message thread.")
+        .argument("<ticketId>", "Ticket UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (ticketId, options) => {
+        await handleAsyncAction("support ticket get", options, () => requestOxygen(`/api/cli/support/tickets/${encodeURIComponent(ticketId)}`));
+    }))
+        .addCommand(new Command("reply")
+        .description("Add a message to a support ticket. Reopens a resolved ticket.")
+        .argument("<ticketId>", "Ticket UUID.")
+        .requiredOption("--body <body>", "Your reply.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (ticketId, options) => {
+        await handleAsyncAction("support ticket reply", options, () => requestOxygen(`/api/cli/support/tickets/${encodeURIComponent(ticketId)}/messages`, {
+            method: "POST",
+            body: { body: readOption(options.body) },
+        }));
+    }))
+        .addCommand(new Command("ack")
+        .description("Mark a resolved ticket as seen so it leaves the unread count.")
+        .argument("<ticketId>", "Ticket UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (ticketId, options) => {
+        await handleAsyncAction("support ticket ack", options, () => requestOxygen(`/api/cli/support/tickets/${encodeURIComponent(ticketId)}/ack`, {
+            method: "POST",
+            body: {},
+        }));
+    }))
+        .addCommand(new Command("admin")
+        .description("Staff-only support triage commands.")
+        .addCommand(new Command("list")
+        .description("List support tickets across all organizations (staff only).")
+        .option("--status <status>", "Filter by status.")
+        .option("--limit <n>", "Max tickets to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("support admin list", options, () => requestOxygen(withSupportListQuery("/api/cli/admin/support/tickets", options)));
+    }))
+        .addCommand(new Command("resolve")
+        .description("Resolve a support ticket and notify the opener (staff only).")
+        .argument("<ticketId>", "Ticket UUID.")
+        .requiredOption("--resolution <text>", "Resolution message sent to the opener.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (ticketId, options) => {
+        await handleAsyncAction("support admin resolve", options, () => requestOxygen(`/api/cli/admin/support/tickets/${encodeURIComponent(ticketId)}/resolve`, {
+            method: "POST",
+            body: { resolution: readOption(options.resolution) },
+        }));
+    })));
+    program
+        .command("feedback")
+        .description("Send feedback or a bug report to the Oxygen team, including your current chat transcript and environment info. Files a tracked ticket; you're notified of the reply by email and on your next session.")
+        .option("-m, --message <message>", "Your feedback or bug report.")
+        .option("--severity <severity>", "low | normal | high. Defaults to normal.")
+        .option("--category <category>", "Optional category label. Defaults to 'feedback'.")
+        .option("--session-id <id>", "Attach a specific local session transcript by id. Defaults to the most recently active session.")
+        .option("--file <path>", "Attach a specific transcript file instead of auto-detecting the current session.")
+        .option("--no-transcript", "Send your note only, without attaching any chat transcript.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("feedback send", options, () => requestOxygen("/api/cli/feedback", {
+            method: "POST",
+            body: buildFeedbackBody(options),
+        }));
+    });
     program
         .command("db")
         .description("Tenant database commands.")
@@ -2288,6 +2383,75 @@ export function createProgram() {
             body: readCompaniesEnrichBody(table, options),
         }));
     })));
+    program
+        .command("people")
+        .description("People and contact prospecting workflows.")
+        .addCommand(new Command("search")
+        .description("Plan, dry-run, or queue provider-backed people/contact search.")
+        .addCommand(new Command("plan")
+        .description("Compile a people-search prompt and optional typed persona filters into ordered provider routes without provider calls.")
+        .requiredOption("--prompt <text-or-file>", "People-search prompt, or a path to a prompt file.")
+        .option("--target-count <n>", "Desired contact count for routing and estimates.")
+        .option("--source-intent <intent>", "Override detected intent: persona_search, account_contacts, audience_sizing, profile_lookup, concept_persona, or fallback_broad.")
+        .option("--filters-json <json-or-file>", "PeopleSearchFilters JSON inline or a @file/path; wins over individual flags per top-level filter path.")
+        .option("--titles <csv>", "Comma-separated job titles to include.")
+        .option("--adjacent-titles <csv>", "Comma-separated adjacent/looser titles to accept.")
+        .option("--exclude-titles <csv>", "Comma-separated job titles to exclude.")
+        .option("--seniorities <csv>", "Comma-separated seniority levels: C-Suite, VP, Director, Manager, Staff.")
+        .option("--departments <csv>", "Comma-separated departments/functions: Sales, Marketing, Engineering, ...")
+        .option("--countries <csv>", "Comma-separated ISO 3166-1 alpha-2 person country codes.")
+        .option("--keywords <csv>", "Comma-separated free-text persona keywords.")
+        .option("--company-domains <csv>", "Comma-separated company domains to scope contacts to.")
+        .option("--company-names <csv>", "Comma-separated company names to scope contacts to.")
+        .option("--employees <range>", "Company employee count range: 20-200, 500+, or -50.")
+        .option("--require-email", "Only return people with a work email available (provider-dependent).")
+        .option("--require-phone", "Only return people with a phone/mobile available (provider-dependent).")
+        .option("--max-per-company <n>", "Cap on contacts per company for account-anchored searches.")
+        .option("--estimate", "Run a free count probe for an estimated match count.")
+        .option("--materialize-preview", "Create a preview table with route rows.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("people search plan", options, () => requestOxygen("/api/cli/people/search/plan", {
+            method: "POST",
+            body: readPeopleSearchPlanBody(options),
+        }));
+    }))
+        .addCommand(new Command("run")
+        .description("Return a dry-run request or queue a live people-search ingestion run. Upsert dedup is on linkedin_url.")
+        .option("--prompt <text-or-file>", "People-search prompt, or a path to a prompt file.")
+        .option("--plan-json <json-or-file>", "Plan JSON returned by people search plan, or a path to a JSON file.")
+        .option("--route-id <id>", "Route id from the plan to execute.")
+        .option("--tool-id <tool>", "Tool id from the plan to execute.")
+        .option("--table <table>", "Existing table id or slug to receive rows. If omitted for live, Oxygen creates a table.")
+        .option("--upsert-key <column>", "Column key used for live upsert. Must match the plan upsert key (linkedin_url).")
+        .option("--mode <mode>", "dry_run or live. Defaults to dry_run.")
+        .option("--max-pages <n>", "Maximum provider pages to ingest. Defaults to the route estimate.")
+        .option("--max-credits <n>", "Required credit ceiling for live runs.")
+        .option("--target-count <n>", "Desired contact count when planning from --prompt.")
+        .option("--source-intent <intent>", "Override detected intent when planning from --prompt.")
+        .option("--filters-json <json-or-file>", "PeopleSearchFilters JSON inline or a @file/path when planning from --prompt; wins over individual flags per top-level filter path.")
+        .option("--titles <csv>", "Comma-separated job titles to include when planning from --prompt.")
+        .option("--adjacent-titles <csv>", "Comma-separated adjacent titles when planning from --prompt.")
+        .option("--exclude-titles <csv>", "Comma-separated job titles to exclude when planning from --prompt.")
+        .option("--seniorities <csv>", "Comma-separated seniority levels when planning from --prompt.")
+        .option("--departments <csv>", "Comma-separated departments/functions when planning from --prompt.")
+        .option("--countries <csv>", "Comma-separated ISO 3166-1 alpha-2 person country codes when planning from --prompt.")
+        .option("--keywords <csv>", "Comma-separated persona keywords when planning from --prompt.")
+        .option("--company-domains <csv>", "Comma-separated company domains when planning from --prompt.")
+        .option("--company-names <csv>", "Comma-separated company names when planning from --prompt.")
+        .option("--employees <range>", "Company employee count range when planning from --prompt.")
+        .option("--require-email", "Only return people with a work email available when planning from --prompt.")
+        .option("--require-phone", "Only return people with a phone available when planning from --prompt.")
+        .option("--max-per-company <n>", "Cap on contacts per company when planning from --prompt.")
+        .option("--estimate", "Run a free count probe when planning from --prompt.")
+        .option("--approved", "Required for live runs after inspecting dry-run output.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("people search run", options, () => requestOxygen("/api/cli/people/search/run", {
+            method: "POST",
+            body: readPeopleSearchRunBody(options),
+        }));
+    })));
     program
         .command("worker")
         .description("Background worker commands.")
@@ -2792,7 +2956,7 @@ export function createProgram() {
         .description("Run an executable Oxygen tool through the HTTPS API.")
         .argument("<tool_id>", "Tool id.")
         .requiredOption("--input-json <json>", "Tool input as a JSON object.")
-        .option("--mode <mode>", "Execution mode: live, dry-run, or dry_run. Mutating tools default to dry-run.")
+        .option("--mode <mode>", "Execution mode: live or dry-run. Mutating tools default to dry-run.")
         .option("--credential-mode <mode>", "Credential mode: managed, user_api_key, or user_oauth.")
         .option("--org <organization_id>", "Optional organization id. Must match the stored CLI token.")
         .option("--org-id <organization_id>", "Optional organization id. Must match the stored CLI token.")
@@ -2841,7 +3005,8 @@ export function createProgram() {
         .option("--provider-order <providers>", "Comma-separated provider order. Overrides the default cost-aware waterfall profile.")
         .option("--email-waterfall-profile <profile>", "Work-email waterfall profile: auto, name_domain, linkedin_url, or first_last_domain. Defaults prefer BlitzAPI/RocketReach/Prospeo where inputs fit.")
         .option("--email-pattern-validation <mode>", "Work-email pattern pre-step: leadmagic_valid_only or disabled.")
-        .option("--verify-phone", "Validate found phone numbers with ClearoutPhone before returning them.")
+        .option("--phone-waterfall-profile <profile>", "Phone waterfall profile: auto (input-aware), linkedin_url, email, or name_domain. Auto picks the cheapest cost-ordered provider set for each row's inputs (mobile match rate ~30-60%).")
+        .option("--verify-phone", "Validate found phone numbers with ClearoutPhone (adds phone_line_type + phone_carrier; filter phone_line_type=mobile for mobile-only).")
         .option("--phone-verification-credential-mode <mode>", "ClearoutPhone credential mode for phone verification: managed or user_api_key.")
         .option("--limit <n>", "Rows to estimate. Defaults to 10.")
         .option("--all", "Estimate all rows.")
@@ -2874,7 +3039,8 @@ export function createProgram() {
         .option("--provider-order <providers>", "Comma-separated provider order. Overrides the default cost-aware waterfall profile.")
         .option("--email-waterfall-profile <profile>", "Work-email waterfall profile: auto, name_domain, linkedin_url, or first_last_domain. Defaults prefer BlitzAPI/RocketReach/Prospeo where inputs fit.")
         .option("--email-pattern-validation <mode>", "Work-email pattern pre-step: leadmagic_valid_only or disabled.")
-        .option("--verify-phone", "Validate found phone numbers with ClearoutPhone before returning them.")
+        .option("--phone-waterfall-profile <profile>", "Phone waterfall profile: auto (input-aware), linkedin_url, email, or name_domain. Auto picks the cheapest cost-ordered provider set for each row's inputs (mobile match rate ~30-60%).")
+        .option("--verify-phone", "Validate found phone numbers with ClearoutPhone (adds phone_line_type + phone_carrier; filter phone_line_type=mobile for mobile-only).")
         .option("--phone-verification-credential-mode <mode>", "ClearoutPhone credential mode for phone verification: managed or user_api_key.")
         .option("--limit <n>", "Rows to queue.")
         .option("--all", "Queue all rows.")
@@ -3019,20 +3185,20 @@ export function createProgram() {
         });
     })))
         .addCommand(new Command("list")
-        .description("List supported Composio integrations and this org's connections.")
+        .description("List supported integrations and this org's connections.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("integrations list", options, async () => requestOxygen("/api/cli/integrations/composio/list"));
     }))
         .addCommand(new Command("connect")
-        .description("Connect a Composio integration. OAuth toolkits return a redirect URL; API-key toolkits accept --api-key.")
+        .description("Connect an integration. OAuth toolkits return a redirect URL; API-key integrations accept --api-key.")
         .argument("<integration_id>", "Integration id, such as 'slack' or 'serpapi'.")
         .option("--api-key <value>", "API key for Composio API-key toolkits (e.g. SerpAPI, Resend).")
         .option("--json", "Print a JSON envelope.")
         .action(async (integrationId, options) => {
         await handleAsyncAction("integrations connect", options, async () => {
             const apiKey = readOption(options.apiKey)?.trim();
-            return requestOxygen("/api/cli/integrations/composio/start", {
+            return requestOxygen("/api/cli/integrations/connect", {
                 method: "POST",
                 body: {
                     integration_id: integrationId,
@@ -3042,13 +3208,13 @@ export function createProgram() {
         });
     }))
         .addCommand(new Command("disconnect")
-        .description("Disconnect a Composio integration.")
+        .description("Disconnect an integration.")
         .argument("<integration_id>", "Integration id, such as 'slack'.")
         .option("--connection-id <id>", "Disconnect a specific connected account when multiple exist.")
         .option("--json", "Print a JSON envelope.")
         .action(async (integrationId, options) => {
         const connectionId = readOption(options.connectionId)?.trim();
-        await handleAsyncAction("integrations disconnect", options, () => requestOxygen("/api/cli/integrations/composio/disconnect", {
+        await handleAsyncAction("integrations disconnect", options, () => requestOxygen("/api/cli/integrations/disconnect", {
             method: "POST",
             body: {
                 integration_id: integrationId,
@@ -3092,18 +3258,15 @@ export function createProgram() {
             });
         });
     }));
-    program
-        .command("linkedin")
-        .description("LinkedIn sender account management for the native LinkedIn sequencer (accounts, limits, usage).")
-        .addCommand(new Command("accounts")
-        .description("Manage the org's connected LinkedIn sender accounts: list, connect, sync, inspect, disconnect, and tune rate limits.")
+    program.addCommand(new Command("senders")
+        .description("Manage the org's connected LinkedIn sender accounts for Sequencer: list, connect, sync, inspect, disconnect, and tune rate limits.")
         .addCommand(new Command("list")
         .description("List connected LinkedIn sender accounts with health status, rate limits, and today's usage.")
         .option("--status <status>", "Filter by sender status: active, paused, disconnected, restricted, or credentials_required.")
         .option("--no-usage", "Skip today's per-account usage counts for a faster, lighter response.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin accounts list", options, () => {
+        await handleAsyncAction("senders list", options, () => {
             const params = new URLSearchParams();
             if (options.usage !== false)
                 params.set("include_usage", "true");
@@ -3111,7 +3274,7 @@ export function createProgram() {
             if (status)
                 params.set("status", status);
             const suffix = params.toString();
-            return requestOxygen(`/api/cli/linkedin/accounts${suffix ? `?${suffix}` : ""}`);
+            return requestOxygen(`/api/cli/senders${suffix ? `?${suffix}` : ""}`);
         });
     }))
         .addCommand(new Command("connect")
@@ -3119,9 +3282,9 @@ export function createProgram() {
         .option("--reconnect <connection_id>", "Reconnect an existing connection instead of creating a new one. Accepts a connection id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin accounts connect", options, () => {
+        await handleAsyncAction("senders connect", options, () => {
             const reconnect = readOption(options.reconnect);
-            return requestOxygen("/api/cli/linkedin/accounts/connect", {
+            return requestOxygen("/api/cli/senders/connect", {
                 method: "POST",
                 body: {
                     ...(reconnect ? { reconnect_connection_id: reconnect } : {}),
@@ -3130,20 +3293,20 @@ export function createProgram() {
         });
     }))
         .addCommand(new Command("get")
-        .description("Get one LinkedIn sender account with status, limits, working hours, and usage. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .description("Get one LinkedIn sender account with status, limits, daily-reset timezone, and usage. <id> accepts a sender account id, connection id, or Unipile account id.")
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("linkedin accounts get", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}`));
+        await handleAsyncAction("senders get", options, async () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}`));
     }))
         .addCommand(new Command("sync")
         .description("Refresh LinkedIn account state (status, profile) from Unipile. Pass --connection-id to sync one account, or omit it to sync all.")
         .option("--connection-id <id>", "Sync a specific connection id. Defaults to syncing all connected accounts.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin accounts sync", options, () => {
+        await handleAsyncAction("senders sync", options, () => {
             const connectionId = readOption(options.connectionId);
-            return requestOxygen("/api/cli/linkedin/accounts/sync", {
+            return requestOxygen("/api/cli/senders/sync", {
                 method: "POST",
                 body: {
                     ...(connectionId ? { connection_id: connectionId } : {}),
@@ -3156,22 +3319,22 @@ export function createProgram() {
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("linkedin accounts disconnect", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/disconnect`, {
+        await handleAsyncAction("senders disconnect", options, async () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/disconnect`, {
             method: "POST",
         }));
     }))
         .addCommand(new Command("limits")
-        .description("View and adjust per-account daily action limits and working hours.")
+        .description("View and adjust per-account daily action limits and the daily-reset timezone.")
         .option("--json", "Print a JSON envelope.")
         .addCommand(new Command("get")
-        .description("Show current limits, overrides, working hours, defaults, and safe maximums for an account. <id> accepts a sender account id, connection id, or Unipile account id.")
+        .description("Show current limits, overrides, daily-reset timezone, defaults, and safe maximums for an account. <id> accepts a sender account id, connection id, or Unipile account id.")
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("linkedin accounts limits get", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/limits`));
+        await handleAsyncAction("senders limits get", options, async () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
     }))
         .addCommand(new Command("set")
-        .description("Adjust per-account daily action limits and working hours. Values are clamped to safe maximums (e.g. max 80 invites/day). <id> accepts a sender account id, connection id, or Unipile account id.")
+        .description("Adjust per-account daily action limits and the daily-reset timezone. Values are clamped to safe maximums (e.g. max 80 invites/day). Send windows (time of day) are set per sequence in the campaign schedule, not per account. <id> accepts a sender account id, connection id, or Unipile account id.")
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--invites-per-day <n>", "Daily LinkedIn connection invites cap.")
         .option("--invites-per-week <n>", "Weekly LinkedIn connection invites cap.")
@@ -3188,21 +3351,18 @@ export function createProgram() {
         .option("--total-reads-per-day <n>", "Daily cap across all read types.")
         .option("--min-spacing-seconds <n>", "Minimum seconds between actions.")
         .option("--spacing-jitter-seconds <n>", "Random jitter seconds added to action spacing.")
-        .option("--timezone <tz>", "IANA timezone for working hours, e.g. America/New_York.")
-        .option("--working-days <days>", "Comma-separated ISO weekdays the account sends, e.g. 1,2,3,4,5 (1=Mon..7=Sun).")
-        .option("--working-start <HH:MM>", "Working hours start time, e.g. 09:00.")
-        .option("--working-end <HH:MM>", "Working hours end time, e.g. 17:00.")
+        .option("--timezone <tz>", "IANA timezone the daily action counters reset in, e.g. America/New_York.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("linkedin accounts limits set", options, () => {
+        await handleAsyncAction("senders limits set", options, () => {
             const body = buildLinkedinLimitsBody(options);
-            return requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/limits`, {
+            return requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`, {
                 method: "PATCH",
                 body,
             });
         });
-    }))))
-        .addCommand(new Command("inbox")
+    }))));
+    program.addCommand(new Command("inbox")
         .description("LinkedIn unified inbox (unibox): scan conversations across all sender accounts, read threads, and reply.")
         .addCommand(new Command("list")
         .description("List LinkedIn conversations across all connected accounts, newest first.")
@@ -3213,7 +3373,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum conversations to return (1-200). Defaults to 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin inbox list", options, () => {
+        await handleAsyncAction("inbox list", options, () => {
             const params = new URLSearchParams();
             const account = readOption(options.account);
             if (account)
@@ -3229,7 +3389,7 @@ export function createProgram() {
             if (limit)
                 params.set("limit", limit);
             const suffix = params.toString();
-            return requestOxygen(`/api/cli/linkedin/inbox${suffix ? `?${suffix}` : ""}`);
+            return requestOxygen(`/api/cli/inbox${suffix ? `?${suffix}` : ""}`);
         });
     }))
         .addCommand(new Command("get")
@@ -3238,13 +3398,13 @@ export function createProgram() {
         .option("--message-limit <n>", "Maximum messages to return (1-500). Defaults to 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("linkedin inbox get", options, () => {
+        await handleAsyncAction("inbox get", options, () => {
             const params = new URLSearchParams();
             const messageLimit = readOption(options.messageLimit);
             if (messageLimit)
                 params.set("message_limit", messageLimit);
             const suffix = params.toString();
-            return requestOxygen(`/api/cli/linkedin/inbox/${encodeURIComponent(conversation)}${suffix ? `?${suffix}` : ""}`);
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}${suffix ? `?${suffix}` : ""}`);
         });
     }))
         .addCommand(new Command("send")
@@ -3254,7 +3414,7 @@ export function createProgram() {
         .option("--approved", "Approve and send the message. Without this flag, returns a preview only.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("linkedin inbox send", options, () => requestOxygen(`/api/cli/linkedin/inbox/${encodeURIComponent(conversation)}/send`, {
+        await handleAsyncAction("inbox send", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/send`, {
             method: "POST",
             body: {
                 text: readOption(options.text),
@@ -3267,7 +3427,7 @@ export function createProgram() {
         .argument("<conversation>", "Conversation id or Unipile chat id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("linkedin inbox mark-read", options, () => requestOxygen(`/api/cli/linkedin/inbox/${encodeURIComponent(conversation)}/read`, {
+        await handleAsyncAction("inbox mark-read", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/read`, {
             method: "POST",
         }));
     }))
@@ -3277,7 +3437,7 @@ export function createProgram() {
         .option("--message-limit <n>", "Maximum messages to sync per chat. Defaults to 20.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin inbox sync", options, () => {
+        await handleAsyncAction("inbox sync", options, () => {
             const body = {};
             const chatLimit = readOption(options.chatLimit);
             if (chatLimit)
@@ -3285,77 +3445,160 @@ export function createProgram() {
             const messageLimit = readOption(options.messageLimit);
             if (messageLimit)
                 body.message_limit = Number(messageLimit);
-            return requestOxygen("/api/cli/linkedin/inbox/sync", { method: "POST", body });
+            return requestOxygen("/api/cli/inbox/sync", { method: "POST", body });
         });
-    })))
-        .addCommand(new Command("sequences")
-        .description("LinkedIn outreach sequences: multi-step campaigns over a lead table dispatched across sender accounts with rate limits and reply-stop.")
+    })));
+    program.addCommand(new Command("sequences")
+        .description("Multichannel outreach sequences: one enrollment per lead spans LinkedIn + email over a journey. LinkedIn steps dispatch natively (rate-limited, credit-capped); email steps send natively or place/move/stop the lead in a bound Instantly campaign (BYOK). Cross-channel reply-stop is intrinsic. A LinkedIn-only sequence behaves exactly like the original sequencer.")
         .addCommand(new Command("list")
-        .description("List LinkedIn sequences with status and credit usage.")
+        .description("List sequences with status, channels, and credit usage.")
         .option("--status <status>", "Filter by status: draft, active, paused, or archived.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin sequences list", options, () => {
+        await handleAsyncAction("sequences list", options, () => {
             const params = new URLSearchParams();
             const status = readOption(options.status);
             if (status)
                 params.set("status", status);
             const suffix = params.toString();
-            return requestOxygen(`/api/cli/linkedin/sequences${suffix ? `?${suffix}` : ""}`);
+            return requestOxygen(`/api/cli/sequences${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("analytics")
+        .description("Show organization-level sequencer analytics plus per-sequence funnels.")
+        .option("--range <range>", "Preset range: 7d, 14d, 28d, or 30d. Defaults to 14d.")
+        .option("--from <date>", "Custom start date (YYYY-MM-DD).")
+        .option("--to <date>", "Custom end date (YYYY-MM-DD).")
+        .option("--sequence <id-or-slug>", "Limit analytics to one sequence.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("sequences analytics", options, () => {
+            const params = new URLSearchParams();
+            const range = readOption(options.range);
+            const from = readOption(options.from);
+            const to = readOption(options.to);
+            const sequence = readOption(options.sequence);
+            if (range)
+                params.set("range", range);
+            if (from)
+                params.set("from", from);
+            if (to)
+                params.set("to", to);
+            if (sequence)
+                params.set("sequence", sequence);
+            const qs = params.toString();
+            return requestOxygen(`/api/cli/sequences/analytics${qs ? `?${qs}` : ""}`);
         });
     }))
         .addCommand(new Command("create")
-        .description("Create a draft sequence from a steps JSON file. Assign sender accounts with --senders.")
+        .description("Create a draft multichannel sequence from a steps JSON file. Assign LinkedIn senders with --senders (required when the journey has LinkedIn steps); bind an Instantly email track with --email-*.")
         .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\": [...] }.")
-        .requiredOption("--senders <ids>", "Comma-separated sender account ids (or connection / Unipile ids).")
+        .requiredOption("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] }. LinkedIn steps (invite | message | wait_for_connection | inmail), email steps (email_send | email_reply | email_enroll | email_move | email_stop), and control steps (wait | wait_for_signal | branch | stop), each with an `id`. A `branch` routes on signals (then/else) or the legacy connection_accepted/already_connected sugar (then_id/else_id).")
+        .option("--channels <list>", "Comma-separated channels: linkedin,email. Defaults to the channels the journey touches.")
+        .option("--senders <ids>", "Comma-separated LinkedIn sender account ids (or connection / Unipile ids). Required when the journey has LinkedIn steps.")
         .option("--table <id>", "Source table id whose rows supply {{column}} template values.")
         .option("--url-column <key>", "Column key holding each lead's LinkedIn URL/provider id.")
-        .option("--max-credits <n>", "Credit cap for the sequence (also set when starting).")
+        .option("--email-provider <provider>", "Email provider for the email track. Only 'instantly' is supported.")
+        .option("--email-connection <id>", "Instantly connection id for the email track. Defaults to the org's active Instantly connection.")
+        .option("--email-definition-file <path>", "Path to a JSON file with the email content spec (subjects/bodies/delays/subsequences) compiled to an Instantly campaign on start.")
+        .option("--max-credits <n>", "Credit cap for the LinkedIn track (also set when starting).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("linkedin sequences create", options, () => {
+        await handleAsyncAction("sequences create", options, () => {
             const stepsPath = readOption(options.stepsFile);
             if (!stepsPath)
                 throw new Error("--steps-file is required.");
             const raw = readFileSync(resolve(stepsPath), "utf8");
             const definition = JSON.parse(raw);
-            const senders = (readOption(options.senders) ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+            const channels = readCsvOption(options.channels);
+            const senders = readCsvOption(options.senders);
+            const email = readCampaignEmailBinding(options);
             const maxCredits = readPositiveNumber(options.maxCredits);
-            return requestOxygen("/api/cli/linkedin/sequences", {
+            return requestOxygen("/api/cli/sequences", {
                 method: "POST",
                 body: {
                     name: readOption(options.name),
                     slug: readOption(options.slug),
                     definition,
-                    senders,
+                    ...(channels.length > 0 ? { channels } : {}),
+                    ...(senders.length > 0 ? { senders } : {}),
                     ...(readOption(options.table) ? { source_table_id: readOption(options.table) } : {}),
                     ...(readOption(options.urlColumn) ? { linkedin_url_column_key: readOption(options.urlColumn) } : {}),
+                    ...(email ? { email } : {}),
                     ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
                 },
             });
         });
+    }))
+        .addCommand(new Command("update")
+        .description("Update a DRAFT sequence's name, journey, channels, senders, email binding, or LinkedIn credit cap. The journey is re-validated; the email binding stays editable only while the sequence is a draft. --max-credits is locked once the sequence has been started (re-run `sequences start`). Pass only the fields you want to change.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--name <name>", "New human-readable sequence name.")
+        .option("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] } replacing the journey.")
+        .option("--channels <list>", "Comma-separated channels: linkedin,email.")
+        .option("--senders <ids>", "Comma-separated LinkedIn sender account ids (or connection / Unipile ids).")
+        .option("--email-provider <provider>", "Email provider for the email track. Only 'instantly' is supported.")
+        .option("--email-connection <id>", "Instantly connection id for the email track.")
+        .option("--email-definition-file <path>", "Path to a JSON file with the email content spec (subjects/bodies/delays/subsequences).")
+        .option("--clear-email", "Remove the email binding from the sequence (draft only).")
+        .option("--max-credits <n>", "Credit cap for the LinkedIn track (draft only).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleAsyncAction("sequences update", options, () => {
+            const body = {};
+            const name = readOption(options.name);
+            if (name)
+                body.name = name;
+            const stepsPath = readOption(options.stepsFile);
+            if (stepsPath) {
+                body.definition = JSON.parse(readFileSync(resolve(stepsPath), "utf8"));
+            }
+            const channels = readCsvOption(options.channels);
+            if (channels.length > 0)
+                body.channels = channels;
+            const senders = readCsvOption(options.senders);
+            if (senders.length > 0)
+                body.senders = senders;
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            if (maxCredits !== undefined)
+                body.max_credits = maxCredits;
+            if (options.clearEmail) {
+                body.email = null;
+            }
+            else {
+                const email = readCampaignEmailBinding(options);
+                if (email)
+                    body.email = email;
+            }
+            if (Object.keys(body).length === 0) {
+                throw new Error("Provide at least one field to update (--name, --steps-file, --channels, --senders, --email-*, --clear-email, or --max-credits).");
+            }
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}`, {
+                method: "PATCH",
+                body,
+            });
+        });
     }))
         .addCommand(new Command("get")
         .description("Get a sequence's definition, senders, status, and credit usage.")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences get", options, () => requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}`));
+        await handleAsyncAction("sequences get", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}`));
     }))
         .addCommand(new Command("enroll")
-        .description("Enroll leads into a sequence from a JSON file of { leads: [...] }. Idempotent per table row.")
+        .description("Enroll leads into a sequence from a JSON file of { leads: [...] }. 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.")
         .argument("<sequence>", "Sequence id or slug.")
-        .requiredOption("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ lead_provider_id, lead_name, row_values }] }.")
+        .requiredOption("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ lead_provider_id, lead_name, table_row_id, row_values }] }.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences enroll", options, () => {
+        await handleAsyncAction("sequences enroll", options, () => {
             const leadsPath = readOption(options.leadsFile);
             if (!leadsPath)
                 throw new Error("--leads-file is required.");
             const parsed = JSON.parse(readFileSync(resolve(leadsPath), "utf8"));
-            return requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/enroll`, {
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enroll`, {
                 method: "POST",
                 body: { leads: parsed.leads ?? [] },
             });
@@ -3369,9 +3612,9 @@ export function createProgram() {
         .option("--dry-run", "Activate in dry-run mode: advance every step with simulated sends, no LinkedIn actions, no credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences start", options, () => {
+        await handleAsyncAction("sequences start", options, () => {
             const maxCredits = readPositiveNumber(options.maxCredits);
-            return requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/start`, {
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/start`, {
                 method: "POST",
                 body: {
                     ...(options.dryRun ? { dry_run: true } : {}),
@@ -3386,7 +3629,7 @@ export function createProgram() {
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences pause", options, () => requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/status`, {
+        await handleAsyncAction("sequences pause", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/status`, {
             method: "POST", body: { status: "paused" },
         }));
     }))
@@ -3395,7 +3638,7 @@ export function createProgram() {
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences resume", options, () => requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/status`, {
+        await handleAsyncAction("sequences resume", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/status`, {
             method: "POST", body: { status: "active" },
         }));
     }))
@@ -3404,7 +3647,7 @@ export function createProgram() {
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences archive", options, () => requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/status`, {
+        await handleAsyncAction("sequences archive", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/status`, {
             method: "POST", body: { status: "archived" },
         }));
     }))
@@ -3415,7 +3658,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum enrollments to return (1-500).")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences enrollments", options, () => {
+        await handleAsyncAction("sequences enrollments", options, () => {
             const params = new URLSearchParams();
             const status = readOption(options.status);
             if (status)
@@ -3424,7 +3667,7 @@ export function createProgram() {
             if (limit)
                 params.set("limit", limit);
             const suffix = params.toString();
-            return requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/enrollments${suffix ? `?${suffix}` : ""}`);
+            return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enrollments${suffix ? `?${suffix}` : ""}`);
         });
     }))
         .addCommand(new Command("stats")
@@ -3432,8 +3675,142 @@ export function createProgram() {
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("linkedin sequences stats", options, () => requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/stats`));
+        await handleAsyncAction("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`));
     })));
+    program.addCommand(new Command("mailboxes")
+        .description("Native email sending pool: register/refresh Google/Microsoft mailboxes a campaign rotates over, pause/disable inboxes, and delegate warmup to Instantly (BYOK — Instantly bills your account, 0 Oxygen credits).")
+        .addCommand(new Command("list")
+        .description("List the org's sending mailboxes with provider, status, warmup state, and a pool overview.")
+        .option("--status <status>", "Filter by status: active, paused, or disabled.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes list", options, () => {
+            const params = new URLSearchParams();
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/mailboxes${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("import")
+        .description("Register (or refresh) sending mailboxes in bulk. Provide --file (a JSON file: { \"mailboxes\": [{ email_address, provider, workspace_external_id? }] }) or --from zapmail to pull the connected Zapmail workspace's mailbox list. Upsert is keyed by address, so re-importing never duplicates a mailbox.")
+        .option("--file <path>", "Path to a JSON file: { \"mailboxes\": [{ email_address, provider, workspace_external_id? }] }.")
+        .option("--from <source>", "Import source: 'zapmail' to pull the connected Zapmail workspace's mailboxes.")
+        .option("--connection <id>", "Zapmail connection id (--from zapmail). Defaults to the org's active Zapmail connection.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes import", options, () => {
+            const from = readOption(options.from);
+            const filePath = readOption(options.file);
+            const connection = readOption(options.connection);
+            if (from === "zapmail") {
+                return requestOxygen("/api/cli/mailboxes", {
+                    method: "POST",
+                    body: { source: "zapmail", ...(connection ? { connection_id: connection } : {}) },
+                });
+            }
+            if (!filePath)
+                throw new Error("Provide --file <path> (a { \"mailboxes\": [...] } JSON file) or --from zapmail.");
+            const parsed = JSON.parse(readFileSync(resolve(filePath), "utf8"));
+            return requestOxygen("/api/cli/mailboxes", {
+                method: "POST",
+                body: { mailboxes: parsed.mailboxes ?? [] },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Set a sending mailbox's status. Pausing/disabling takes the inbox out of the rotation pool without losing its warmup state.")
+        .argument("<mailbox>", "Mailbox id or email address.")
+        .requiredOption("--status <status>", "New status: active, paused, or disabled.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (mailbox, options) => {
+        await handleAsyncAction("mailboxes status", options, () => {
+            const status = readOption(options.status);
+            if (!status)
+                throw new Error("--status is required.");
+            return requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}/status`, {
+                method: "POST",
+                body: { status },
+            });
+        });
+    }))
+        .addCommand(new Command("connect-oauth")
+        .description("Provision Zapmail Custom OAuth across the mailbox pool: registers Oxygen's own OAuth app with Zapmail, which authorizes it across the Workspaces so native send needs no per-Workspace delegation. BYOK — Zapmail bills your account, 0 Oxygen credits. Pass --status <export_id> to poll a run.")
+        .option("--provider <provider>", "Mailbox provider to provision: google or microsoft.")
+        .option("--mailboxes <list>", "Comma-separated mailbox addresses to provision. Omit to provision the whole pool for the provider.")
+        .option("--connection <id>", "Zapmail connection id. Defaults to the org's active Zapmail connection.")
+        .option("--status <export_id>", "Poll a previously started Custom OAuth export instead of starting a new one.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes connect-oauth", options, () => {
+            const exportId = readOption(options.status);
+            if (exportId) {
+                const params = new URLSearchParams({ export_id: exportId });
+                const pollConnection = readOption(options.connection);
+                if (pollConnection)
+                    params.set("connection_id", pollConnection);
+                return requestOxygen(`/api/cli/mailboxes/connect-oauth?${params.toString()}`);
+            }
+            const provider = readOption(options.provider);
+            if (!provider) {
+                throw new Error("--provider <google|microsoft> is required (or pass --status <export_id> to poll a run).");
+            }
+            const mailboxes = readCsvOption(options.mailboxes);
+            const connection = readOption(options.connection);
+            return requestOxygen("/api/cli/mailboxes/connect-oauth", {
+                method: "POST",
+                body: {
+                    provider,
+                    ...(mailboxes.length > 0 ? { mailboxes } : {}),
+                    ...(connection ? { connection_id: connection } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("warmup")
+        .description("Mailbox warmup via Instantly (BYOK — Instantly bills your account, 0 Oxygen credits).")
+        .addCommand(new Command("enable")
+        .description("Enable Instantly warmup for sending mailboxes and stamp each mailbox's warmup state. Targets the whole pool unless --mailboxes is given.")
+        .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses to warm. Omit to warm the whole pool.")
+        .option("--connection <id>", "Instantly connection id. Defaults to the org's active Instantly connection.")
+        .option("--dry-run", "Simulate without calling Instantly (mailboxes marked pending).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes warmup enable", options, () => {
+            const mailboxes = readCsvOption(options.mailboxes);
+            const connection = readOption(options.connection);
+            return requestOxygen("/api/cli/mailboxes/warmup", {
+                method: "POST",
+                body: {
+                    ...(mailboxes.length > 0 ? { mailboxes } : {}),
+                    ...(connection ? { connection_id: connection } : {}),
+                    ...(options.dryRun ? { dry_run: true } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Sync Instantly's warmup analytics into the pool, updating each mailbox's warmup state. Targets the whole pool unless --mailboxes is given.")
+        .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses to sync. Omit to sync the whole pool.")
+        .option("--connection <id>", "Instantly connection id. Defaults to the org's active Instantly connection.")
+        .option("--dry-run", "Skip the Instantly call (mailboxes marked pending).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("mailboxes warmup status", options, () => {
+            const params = new URLSearchParams();
+            const mailboxes = readCsvOption(options.mailboxes);
+            if (mailboxes.length > 0)
+                params.set("mailboxes", mailboxes.join(","));
+            const connection = readOption(options.connection);
+            if (connection)
+                params.set("connection_id", connection);
+            if (options.dryRun)
+                params.set("dry_run", "true");
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/mailboxes/warmup/status${suffix ? `?${suffix}` : ""}`);
+        });
+    }))));
     program
         .command("workflows")
         .description("Durable workflow automation commands.")
@@ -4548,6 +4925,112 @@ function readCompanySearchPlanJson(value) {
         ? data
         : parsed;
 }
+function readPeopleSearchPlanBody(options) {
+    const targetCount = readPositiveInt(options.targetCount);
+    const filters = readPeopleSearchFilters(options);
+    return {
+        prompt: readFileIfPresent(options.prompt),
+        ...(targetCount !== undefined ? { target_count: targetCount } : {}),
+        ...(options.sourceIntent ? { source_intent: options.sourceIntent } : {}),
+        ...(filters ? { filters } : {}),
+        ...(options.estimate ? { estimate: true } : {}),
+        ...(options.materializePreview ? { materialize_preview: true } : {}),
+    };
+}
+function readPeopleSearchRunBody(options) {
+    const prompt = options.prompt ? readFileIfPresent(options.prompt) : null;
+    const plan = options.planJson ? readPeopleSearchPlanJson(options.planJson) : null;
+    if (!prompt && !plan) {
+        throw new OxygenError("invalid_request", "Pass --prompt or --plan-json.", { exitCode: 1 });
+    }
+    const maxPages = readPositiveInt(options.maxPages);
+    const maxCredits = readPositiveNumber(options.maxCredits);
+    const targetCount = readPositiveInt(options.targetCount);
+    const filters = prompt ? readPeopleSearchFilters(options) : null;
+    return {
+        ...(prompt ? { prompt } : {}),
+        ...(plan ? { plan } : {}),
+        ...(options.routeId ? { route_id: options.routeId } : {}),
+        ...(options.toolId ? { tool_id: options.toolId } : {}),
+        ...(options.table ? { table: options.table } : {}),
+        ...(options.upsertKey ? { upsert_key: options.upsertKey } : {}),
+        ...(options.mode ? { mode: options.mode } : {}),
+        ...(maxPages !== undefined ? { max_pages: maxPages } : {}),
+        ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+        ...(targetCount !== undefined ? { target_count: targetCount } : {}),
+        ...(options.sourceIntent ? { source_intent: options.sourceIntent } : {}),
+        ...(filters ? { filters } : {}),
+        ...(prompt && options.estimate ? { estimate: true } : {}),
+        ...(options.approved ? { approved: true } : {}),
+    };
+}
+// PeopleSearchFilters mirror (structural — the server validates the shape). Builds a
+// filters object from individual --titles/--seniorities/etc. flags, then lets --filters-json
+// win per top-level filter path so an agent can pass a precise object while still using
+// convenience flags for the rest.
+function readPeopleSearchFilters(options) {
+    const filters = {};
+    const titles = {};
+    const titleInclude = readCsvOption(options.titles);
+    if (titleInclude.length > 0)
+        titles.include = titleInclude;
+    const adjacent = readCsvOption(options.adjacentTitles);
+    if (adjacent.length > 0)
+        titles.include_adjacent = adjacent;
+    const titleExclude = readCsvOption(options.excludeTitles);
+    if (titleExclude.length > 0)
+        titles.exclude = titleExclude;
+    if (Object.keys(titles).length > 0)
+        filters.titles = titles;
+    const seniorities = readCsvOption(options.seniorities);
+    if (seniorities.length > 0)
+        filters.seniorities = { include: seniorities };
+    const departments = readCsvOption(options.departments);
+    if (departments.length > 0)
+        filters.departments = { include: departments };
+    const keywords = readCsvOption(options.keywords);
+    if (keywords.length > 0)
+        filters.keywords = { include: keywords };
+    const countries = readCsvOption(options.countries);
+    if (countries.length > 0)
+        filters.geo = { countries };
+    const contactability = {};
+    if (options.requireEmail)
+        contactability.require_work_email = true;
+    if (options.requirePhone)
+        contactability.require_mobile = true;
+    if (Object.keys(contactability).length > 0)
+        filters.contactability = contactability;
+    const company = {};
+    const companyDomains = readCsvOption(options.companyDomains);
+    if (companyDomains.length > 0)
+        company.domains = { include: companyDomains };
+    const companyNames = readCsvOption(options.companyNames);
+    if (companyNames.length > 0)
+        company.names = { include: companyNames };
+    const employees = readRangeOption(options.employees, "--employees");
+    if (employees)
+        company.employee_count = employees;
+    if (Object.keys(company).length > 0)
+        filters.company = company;
+    const maxPerCompany = readPositiveInt(options.maxPerCompany);
+    if (maxPerCompany !== undefined)
+        filters.max_results_per_company = maxPerCompany;
+    const explicit = options.filtersJson ? parseJsonObject(readFileIfPresent(options.filtersJson)) : null;
+    if (explicit) {
+        for (const [key, value] of Object.entries(explicit)) {
+            filters[key] = value;
+        }
+    }
+    return Object.keys(filters).length > 0 ? filters : null;
+}
+function readPeopleSearchPlanJson(value) {
+    const parsed = parseJsonObject(readFileIfPresent(value));
+    const data = parsed.data;
+    return data && typeof data === "object" && !Array.isArray(data)
+        ? data
+        : parsed;
+}
 function readCompaniesEnrichBody(table, options) {
     const body = { table };
     const fields = readCsvOption(options.missingFields);
@@ -4668,6 +5151,9 @@ async function importRows(table, options) {
     const sourceHash = hashImportFile(options.file);
     const shouldUseBackground = options.background
         || (!options.sync && parsedRows.length > LARGE_IMPORT_BACKGROUND_ROW_THRESHOLD);
+    const preparedBackgroundTarget = shouldUseBackground && table && !options.create
+        ? await prepareImportTarget(table, options, parsedRows)
+        : null;
     if (shouldUseBackground) {
         // Prefer the object-storage fast path: upload the raw file once via a
         // presigned URL (no request-body limit) so the worker COPY-loads it.
@@ -4675,13 +5161,13 @@ async function importRows(table, options) {
         const staged = await tryEnqueueStagedFileImport(table, options, format, parsedRows, {
             autoBackground: !options.background,
             sourceHash,
-        });
+        }, preparedBackgroundTarget);
         if (staged)
             return staged;
         return enqueueImportFile(table, options, format, batchSize, {
             autoBackground: !options.background,
             sourceHash,
-        });
+        }, preparedBackgroundTarget);
     }
     const target = await prepareImportTarget(table, options, parsedRows);
     let rowCount = 0;
@@ -4691,28 +5177,30 @@ async function importRows(table, options) {
     const warnings = [];
     let warningsTruncated = false;
     let lastResult = null;
+    let writeRequestCount = 0;
+    let requestTooLargeRetries = 0;
+    let minimumBatchSizeUsed = null;
     for (const batch of chunk(target.rows, batchSize)) {
-        const result = await requestOxygen(target.upsertKey ? "/api/cli/tables/rows/upsert" : "/api/cli/tables/rows", {
-            method: "POST",
-            timeoutMs: 300_000,
-            body: {
-                table: target.tableRef,
-                rows: batch,
-                ...(target.upsertKey ? { key: target.upsertKey } : {}),
-            },
+        const result = await writeImportBatchWithAutoSplit({
+            tableRef: target.tableRef,
+            upsertKey: target.upsertKey,
+            rows: batch,
         });
-        rowCount += readCount(result.rowCount);
-        insertedCount += readCount(result.insertedCount);
-        updatedCount += readCount(result.updatedCount);
-        const batchWarningCount = readCount(result.warningCount);
-        warningCount += batchWarningCount;
-        const batchWarnings = Array.isArray(result.warnings) ? result.warnings : [];
-        for (const warning of batchWarnings) {
+        rowCount += result.rowCount;
+        insertedCount += result.insertedCount;
+        updatedCount += result.updatedCount;
+        warningCount += result.warningCount;
+        for (const warning of result.warnings) {
             if (warnings.length < 20)
                 warnings.push(warning);
         }
-        warningsTruncated = warningsTruncated || result.warningsTruncated === true || warningCount > warnings.length;
-        lastResult = result;
+        warningsTruncated = warningsTruncated || result.warningsTruncated || warningCount > warnings.length;
+        writeRequestCount += result.writeRequestCount;
+        requestTooLargeRetries += result.requestTooLargeRetries;
+        minimumBatchSizeUsed = minimumBatchSizeUsed === null
+            ? result.minimumBatchSizeUsed
+            : Math.min(minimumBatchSizeUsed, result.minimumBatchSizeUsed);
+        lastResult = result.lastResult;
     }
     return {
         table: lastResult?.table ?? null,
@@ -4725,8 +5213,12 @@ async function importRows(table, options) {
             warningCount,
             ...(warningsTruncated ? { warningsTruncated: true } : {}),
         } : {}),
-        batchCount: Math.ceil(target.rows.length / batchSize),
+        batchCount: writeRequestCount,
         batchSize,
+        ...(requestTooLargeRetries > 0 ? {
+            requestTooLargeRetries,
+            minimumBatchSizeUsed,
+        } : {}),
         ...(target.tableWebUrl ? { table_web_url: target.tableWebUrl } : {}),
         ...(readRecordString(lastResult, "web_url") ? { web_url: readRecordString(lastResult, "web_url") } : {}),
     };
@@ -4743,13 +5235,14 @@ async function prepareImportTarget(table, options, parsedRows) {
         });
     }
     if (!options.create) {
+        const keyMapping = await resolveExistingTableImportKeyMapping(table, parsedRows, readOption(options.upsertKey) ?? undefined);
         return {
             tableRef: table,
-            rows: parsedRows,
+            rows: remapImportRows(parsedRows, keyMapping.sourceKeyMap),
             createdTable: null,
             tableWebUrl: null,
-            upsertKey: options.upsertKey,
-            sourceKeyMap: null,
+            upsertKey: keyMapping.upsertKey,
+            sourceKeyMap: keyMapping.sourceKeyMap,
         };
     }
     const normalized = normalizeRowsForNewTable(parsedRows);
@@ -4779,8 +5272,137 @@ async function prepareImportTarget(table, options, parsedRows) {
         sourceKeyMap: normalized.keyBySource,
     };
 }
+async function resolveExistingTableImportKeyMapping(table, rows, upsertKey) {
+    const describe = await requestOxygen("/api/cli/tables/describe", { method: "POST", body: { table } });
+    const resolver = buildExistingTableColumnResolver(describe.columns ?? []);
+    const sourceKeyMap = {};
+    for (const sourceKey of inferImportColumnLabels(rows)) {
+        const resolved = resolveImportSourceKey(sourceKey, resolver);
+        if (resolved && resolved !== sourceKey)
+            sourceKeyMap[sourceKey] = resolved;
+    }
+    return {
+        sourceKeyMap: Object.keys(sourceKeyMap).length > 0 ? sourceKeyMap : null,
+        upsertKey: upsertKey
+            ? resolveImportSourceKey(upsertKey, resolver) ?? upsertKey
+            : undefined,
+    };
+}
+function buildExistingTableColumnResolver(columns) {
+    const exact = new Map();
+    const aliases = new Map();
+    for (const column of columns) {
+        if (!column.key)
+            continue;
+        exact.set(column.key, column.key);
+        addImportColumnAlias(aliases, column.label, column.key);
+        addImportColumnAlias(aliases, normalizeImportColumnKey(column.key), column.key);
+        if (column.label)
+            addImportColumnAlias(aliases, normalizeImportColumnKey(column.label), column.key);
+    }
+    return { exact, aliases };
+}
+function addImportColumnAlias(aliases, alias, key) {
+    const normalizedAlias = alias?.trim();
+    if (!normalizedAlias)
+        return;
+    const existing = aliases.get(normalizedAlias);
+    if (existing === undefined) {
+        aliases.set(normalizedAlias, key);
+        return;
+    }
+    if (existing !== key)
+        aliases.set(normalizedAlias, null);
+}
+function resolveImportSourceKey(sourceKey, resolver) {
+    const trimmed = sourceKey.trim();
+    return resolver.exact.get(sourceKey)
+        ?? resolver.exact.get(trimmed)
+        ?? readImportColumnAlias(resolver.aliases, sourceKey)
+        ?? readImportColumnAlias(resolver.aliases, trimmed)
+        ?? readImportColumnAlias(resolver.aliases, normalizeImportColumnKey(sourceKey));
+}
+function readImportColumnAlias(aliases, alias) {
+    return aliases.get(alias) ?? null;
+}
+function remapImportRows(rows, sourceKeyMap) {
+    if (!sourceKeyMap)
+        return rows;
+    return rows.map((row) => {
+        const remapped = {};
+        for (const [key, value] of Object.entries(row)) {
+            remapped[sourceKeyMap[key] ?? key] = value;
+        }
+        return remapped;
+    });
+}
+async function writeImportBatchWithAutoSplit(input) {
+    try {
+        const result = await requestOxygen(input.upsertKey ? "/api/cli/tables/rows/upsert" : "/api/cli/tables/rows", {
+            method: "POST",
+            timeoutMs: 300_000,
+            body: {
+                table: input.tableRef,
+                rows: input.rows,
+                ...(input.upsertKey ? { key: input.upsertKey } : {}),
+            },
+        });
+        return summarizeImportBatchWrite(result, input.rows.length);
+    }
+    catch (error) {
+        if (!isRequestTooLargeError(error) || input.rows.length <= 1)
+            throw error;
+        const midpoint = Math.ceil(input.rows.length / 2);
+        process.stderr.write(`note: import batch of ${input.rows.length} rows exceeded the request limit; `
+            + `retrying as ${midpoint} and ${input.rows.length - midpoint} row batches.\n`);
+        const first = await writeImportBatchWithAutoSplit({
+            ...input,
+            rows: input.rows.slice(0, midpoint),
+        });
+        const second = await writeImportBatchWithAutoSplit({
+            ...input,
+            rows: input.rows.slice(midpoint),
+        });
+        return combineImportBatchWriteSummaries(first, second, 1);
+    }
+}
+function summarizeImportBatchWrite(result, batchSize) {
+    const warningCount = readCount(result.warningCount);
+    const batchWarnings = Array.isArray(result.warnings) ? result.warnings : [];
+    return {
+        rowCount: readCount(result.rowCount),
+        insertedCount: readCount(result.insertedCount),
+        updatedCount: readCount(result.updatedCount),
+        warningCount,
+        warnings: batchWarnings.slice(0, 20),
+        warningsTruncated: result.warningsTruncated === true || warningCount > batchWarnings.length,
+        writeRequestCount: 1,
+        requestTooLargeRetries: 0,
+        minimumBatchSizeUsed: batchSize,
+        lastResult: result,
+    };
+}
+function combineImportBatchWriteSummaries(first, second, extraRequestTooLargeRetries) {
+    const warnings = [...first.warnings, ...second.warnings].slice(0, 20);
+    const warningCount = first.warningCount + second.warningCount;
+    return {
+        rowCount: first.rowCount + second.rowCount,
+        insertedCount: first.insertedCount + second.insertedCount,
+        updatedCount: first.updatedCount + second.updatedCount,
+        warningCount,
+        warnings,
+        warningsTruncated: first.warningsTruncated || second.warningsTruncated || warningCount > warnings.length,
+        writeRequestCount: first.writeRequestCount + second.writeRequestCount,
+        requestTooLargeRetries: first.requestTooLargeRetries + second.requestTooLargeRetries + extraRequestTooLargeRetries,
+        minimumBatchSizeUsed: Math.min(first.minimumBatchSizeUsed, second.minimumBatchSizeUsed),
+        lastResult: second.lastResult ?? first.lastResult,
+    };
+}
+function isRequestTooLargeError(error) {
+    return error instanceof OxygenError && error.code === "request_too_large";
+}
 async function tryEnqueueStagedFileImport(// skipcq: JS-R1005
-table, options, format, parsedRows, context) {
+table, options, format, parsedRows, context, preparedTarget = null) {
     if (options.create && table) {
         throw new OxygenError("invalid_import_target", "Pass either a table argument or --create, not both.", {
             exitCode: 1,
@@ -4817,7 +5439,7 @@ table, options, format, parsedRows, context) {
         return null;
     // Create the table for --create (or resolve the existing ref) before the
     // upload so a presign success always pairs with a real target.
-    const target = await prepareImportTarget(table, options, parsedRows);
+    const target = preparedTarget ?? await prepareImportTarget(table, options, parsedRows);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 300_000);
     let putResponse;
@@ -4862,7 +5484,7 @@ table, options, format, parsedRows, context) {
         storage_provider: storageProvider,
     };
 }
-async function enqueueImportFile(table, options, format, batchSize, context) {
+async function enqueueImportFile(table, options, format, batchSize, context, preparedTarget = null) {
     if (options.create && table) {
         throw new OxygenError("invalid_import_target", "Pass either a table argument or --create, not both.", {
             exitCode: 1,
@@ -4883,16 +5505,20 @@ async function enqueueImportFile(table, options, format, batchSize, context) {
     form.append("batch_size", String(batchSize));
     form.append("auto_background", String(context.autoBackground));
     form.append("source_hash", context.sourceHash);
-    if (table)
-        form.append("table", table);
-    if (options.create)
+    const targetTable = preparedTarget?.tableRef ?? table;
+    if (targetTable)
+        form.append("table", targetTable);
+    if (!preparedTarget && options.create)
         form.append("table_name", options.create);
     const project = readOption(options.project);
     if (project)
         form.append("project", project);
-    const upsertKey = readOption(options.upsertKey);
+    const upsertKey = preparedTarget?.upsertKey ?? readOption(options.upsertKey);
     if (upsertKey)
         form.append("upsert_key", upsertKey);
+    if (preparedTarget?.sourceKeyMap) {
+        form.append("source_key_map", JSON.stringify(preparedTarget.sourceKeyMap));
+    }
     if (options.sheet)
         form.append("sheet", options.sheet);
     const maxConcurrency = readPositiveInt(options.maxConcurrency);
@@ -5500,7 +6126,7 @@ function formatRows(rows, format, columns) {
     const lines = [renderRow(headers), separator, ...formattedRows.map(renderRow)];
     if (rescuedCount > 0) {
         lines.push("");
-        lines.push(`# Note: reformatted ${rescuedCount} cell${rescuedCount === 1 ? "" : "s"} that look numeric in text columns. Run \`oxygen columns retype --to numeric\` to make this permanent.`);
+        lines.push(`# Note: reformatted ${rescuedCount} cell${rescuedCount === 1 ? "" : "s"} that look numeric in text columns. Run \`oxygen columns retype <table> <column> --data-type numeric\` to make this permanent.`);
     }
     return { content: `${lines.join("\n")}\n`, rescuedCount };
 }
@@ -6731,6 +7357,93 @@ function ansi(enabled) {
 function readOption(value) {
     return value?.trim() ? value.trim() : null;
 }
+// Assemble the POST body for `oxygen feedback`. Reads the local chat transcript
+// (unless --no-transcript) and attaches a non-sensitive environment snapshot so
+// the Oxygen team can triage. The transcript read happens here, inside the
+// command action, so any failure surfaces in the JSON envelope.
+function buildFeedbackBody(options) {
+    const message = readOption(options.message);
+    if (!message) {
+        throw new OxygenError("invalid_input", 'Provide your feedback with --message "...".', { exitCode: 1 });
+    }
+    const body = {
+        message,
+        category: readOption(options.category) ?? "feedback",
+        context: {
+            cli_version: OXYGEN_VERSION,
+            environment: collectFeedbackEnvironment(),
+        },
+    };
+    if (readOption(options.severity))
+        body.severity = readOption(options.severity);
+    if (options.transcript !== false) {
+        try {
+            const captured = captureCurrentTranscript({
+                sessionId: readOption(options.sessionId),
+                file: readOption(options.file),
+            });
+            if (captured) {
+                const { path: _path, ...payload } = captured;
+                body.transcript = payload;
+            }
+            else {
+                process.stderr.write("note: no local chat transcript found; sending your note without one.\n");
+            }
+        }
+        catch (error) {
+            if (error instanceof TranscriptCaptureError) {
+                throw new OxygenError("transcript_not_found", error.message, { exitCode: 1 });
+            }
+            throw error;
+        }
+    }
+    return body;
+}
+function splitCsvOption(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+function buildSupportTicketBody(options) {
+    const body = { subject: readOption(options.subject) };
+    if (readOption(options.body))
+        body.body = readOption(options.body);
+    if (readOption(options.severity))
+        body.severity = readOption(options.severity);
+    if (readOption(options.category))
+        body.category = readOption(options.category);
+    const context = {};
+    if (readOption(options.operation))
+        context.operation = readOption(options.operation);
+    if (readOption(options.errorCode))
+        context.error_code = readOption(options.errorCode);
+    const runIds = splitCsvOption(options.runIds);
+    const tableIds = splitCsvOption(options.tableIds);
+    const deepLinks = splitCsvOption(options.deepLinks);
+    if (runIds.length)
+        context.run_ids = runIds;
+    if (tableIds.length)
+        context.table_ids = tableIds;
+    if (deepLinks.length)
+        context.deep_links = deepLinks;
+    if (Object.keys(context).length)
+        body.context = context;
+    return body;
+}
+function withSupportListQuery(path, options) {
+    const params = new URLSearchParams();
+    const status = readOption(options.status);
+    const limit = readOption(options.limit);
+    if (status)
+        params.set("status", status);
+    if (limit)
+        params.set("limit", limit);
+    const query = params.toString();
+    return query ? `${path}?${query}` : path;
+}
 function readCsvOption(value) {
     const option = readOption(value);
     if (!option)
@@ -6746,6 +7459,26 @@ function splitCsv(value) {
         .map((entry) => entry.trim())
         .filter(Boolean);
 }
+// Assemble the optional campaign email binding from the --email-* flags. The
+// content spec (--email-definition-file) is the author-provided email sequence
+// that the API compiles to an Instantly campaign on start; provider/connection
+// pick which Instantly account to bind. Returns undefined when no email flags
+// are set (a LinkedIn-only campaign).
+function readCampaignEmailBinding(options) {
+    const provider = readOption(options.emailProvider);
+    const connectionId = readOption(options.emailConnection);
+    const definitionPath = readOption(options.emailDefinitionFile);
+    if (!provider && !connectionId && !definitionPath)
+        return undefined;
+    const definition = definitionPath
+        ? JSON.parse(readFileSync(resolve(definitionPath), "utf8"))
+        : undefined;
+    return {
+        ...(provider ? { provider } : {}),
+        ...(connectionId ? { connection_id: connectionId } : {}),
+        ...(definition !== undefined ? { definition } : {}),
+    };
+}
 function collectMultiple(value, previous) {
     return [...previous, value];
 }
@@ -6908,6 +7641,9 @@ table, options) {
         ...(readOption(options.emailPatternValidation)
             ? { email_pattern_validation: readOption(options.emailPatternValidation) }
             : {}),
+        ...(readOption(options.phoneWaterfallProfile)
+            ? { phone_waterfall_profile: readOption(options.phoneWaterfallProfile) }
+            : {}),
         ...(options.verifyPhone ? { verify_phone: true } : {}),
         ...(readOption(options.phoneVerificationCredentialMode)
             ? { phone_verification_credential_mode: readOption(options.phoneVerificationCredentialMode) }
@@ -6919,22 +7655,7 @@ table, options) {
         ...(options.onlyMissing ? { only_missing: true } : {}),
     };
 }
-function readWorkingDaysOption(value) {
-    if (!readOption(value))
-        return undefined;
-    const days = readCsvOption(value).map((entry) => {
-        const parsed = Number(entry);
-        if (!Number.isInteger(parsed) || parsed < 1 || parsed > 7) {
-            throw new OxygenError("invalid_request", "--working-days must be comma-separated ISO weekdays 1-7 (1=Mon..7=Sun).", {
-                details: { value },
-                exitCode: 1,
-            });
-        }
-        return parsed;
-    });
-    return days;
-}
-function buildLinkedinLimitsBody(// skipcq: JS-R1005 -- CLI body builder maps per-account limit and working-hours flags.
+function buildLinkedinLimitsBody(// skipcq: JS-R1005 -- CLI body builder maps per-account limit flags + reset timezone.
 options) {
     const limits = {};
     const setLimit = (key, value) => {
@@ -6957,23 +7678,16 @@ options) {
     setLimit("total_reads_per_day", options.totalReadsPerDay);
     setLimit("min_action_spacing_seconds", options.minSpacingSeconds);
     setLimit("action_spacing_jitter_seconds", options.spacingJitterSeconds);
+    // Send windows are campaign-scoped; the only per-account time setting is the
+    // timezone the daily counters reset in.
     const workingHours = {};
     const timezone = readOption(options.timezone);
     if (timezone)
         workingHours.timezone = timezone;
-    const days = readWorkingDaysOption(options.workingDays);
-    if (days !== undefined)
-        workingHours.days = days;
-    const start = readOption(options.workingStart);
-    if (start)
-        workingHours.start = start;
-    const end = readOption(options.workingEnd);
-    if (end)
-        workingHours.end = end;
     const hasLimits = Object.keys(limits).length > 0;
     const hasWorkingHours = Object.keys(workingHours).length > 0;
     if (!hasLimits && !hasWorkingHours) {
-        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day) or working-hours flag (e.g. --timezone, --working-days).", { exitCode: 1 });
+        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day) or --timezone.", { exitCode: 1 });
     }
     return {
         ...(hasLimits ? { limits } : {}),