@oxygen-agent/cli 1.152.15 → 1.162.10

package/dist/index.js

@@ -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";
@@ -136,6 +137,82 @@ function parseJsonArray(value) {
     }
     return parsed;
 }
+async function readDeleteRowIdsOption(options) {
+    const rowIdsJson = readOption(options.rowIdsJson);
+    const rowIdsFile = readOption(options.rowIdsFile);
+    if (rowIdsJson && rowIdsFile) {
+        throw new OxygenError("invalid_request", "Pass either --row-ids-json or --row-ids-file, not both.", {
+            exitCode: 1,
+        });
+    }
+    if (!rowIdsJson && !rowIdsFile) {
+        throw new OxygenError("invalid_request", "Pass --row-ids-json or --row-ids-file.", {
+            exitCode: 1,
+        });
+    }
+    if (rowIdsJson)
+        return normalizeDeleteRowIds(parseJsonArray(rowIdsJson));
+    const filePath = resolve(rowIdsFile ?? "");
+    const buffer = readFileSync(filePath);
+    const format = normalizeRowsFormat(options.format, inferRowsFileFormat(filePath));
+    if (format === "json") {
+        const text = buffer.toString("utf8");
+        const inlineIds = tryParseJsonStringArray(text);
+        if (inlineIds)
+            return normalizeDeleteRowIds(inlineIds);
+        if (!options.format && !text.trimStart().startsWith("[")) {
+            return normalizeDeleteRowIds(parsePlainRowIdList(text));
+        }
+    }
+    const sheet = readOption(options.sheet);
+    const rows = await parseRowsFileBuffer(buffer, format, sheet ? { sheet } : {});
+    const rowIdColumn = readOption(options.rowIdColumn) ?? "_row_id";
+    return normalizeDeleteRowIds(rows.map((row, index) => {
+        const value = row[rowIdColumn];
+        if (typeof value !== "string" || !value.trim()) {
+            throw new OxygenError("invalid_request", `Row id column "${rowIdColumn}" must contain row UUID strings.`, {
+                details: { row_number: index + 1, column: rowIdColumn },
+                exitCode: 1,
+            });
+        }
+        return value.trim();
+    }));
+}
+function tryParseJsonStringArray(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(parsed) || !parsed.every((entry) => typeof entry === "string"))
+        return null;
+    return parsed;
+}
+function parsePlainRowIdList(value) {
+    return value
+        .split(/[\n,]/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function normalizeDeleteRowIds(values) {
+    const rowIds = values.map((value, index) => {
+        if (typeof value !== "string" || !value.trim()) {
+            throw new OxygenError("invalid_request", "Row IDs must be non-empty strings.", {
+                details: { index },
+                exitCode: 1,
+            });
+        }
+        return value.trim();
+    });
+    if (rowIds.length === 0) {
+        throw new OxygenError("invalid_request", "Row ID list cannot be empty.", {
+            exitCode: 1,
+        });
+    }
+    return rowIds;
+}
 function readCustomIntegrationManifest(options) {
     const manifestPath = readOption(options.manifest);
     const manifestJson = readOption(options.manifestJson);
@@ -426,6 +503,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.")
@@ -671,6 +842,27 @@ export function createProgram() {
                 row_id: rowId,
             },
         }));
+    }))
+        .addCommand(new Command("delete-rows")
+        .description("Delete multiple workspace table rows.")
+        .argument("<table>", "Table id or slug.")
+        .option("--row-ids-json <json>", "JSON array of workspace row UUIDs.")
+        .option("--row-ids-file <path>", "File containing row UUIDs or rows with a _row_id column.")
+        .option("--row-id-column <key>", "Column to read from --row-ids-file. Defaults to _row_id.")
+        .option("--format <format>", "File format for --row-ids-file: json, jsonl, csv, or xlsx.")
+        .option("--sheet <name>", "Worksheet name when reading row IDs from an XLSX file.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables delete-rows", options, async () => {
+            const rowIds = await readDeleteRowIdsOption(options);
+            return requestOxygen("/api/cli/tables/rows/delete", {
+                method: "POST",
+                body: {
+                    table,
+                    row_ids: rowIds,
+                },
+            });
+        });
     }))
         .addCommand(new Command("upsert")
         .description("Insert or update rows in a workspace table by a column key.")
@@ -2288,6 +2480,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 +3053,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 +3102,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 +3136,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 +3282,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 +3305,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 +3355,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 +3371,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 +3379,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 +3390,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 +3416,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 +3448,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 +3470,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 +3486,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 +3495,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 +3511,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 +3524,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 +3534,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 +3542,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 +3709,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 +3726,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 +3735,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 +3744,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 +3755,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 +3764,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 +3772,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 +5022,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 +5248,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 +5258,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 +5274,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 +5310,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 +5332,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 +5369,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 +5536,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 +5581,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 +5602,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 +6223,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 +7454,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 +7556,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 +7738,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 +7752,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 +7775,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 } : {}),