@oxygen-agent/cli 1.142.4 → 1.152.15

package/dist/index.js

@@ -45,6 +45,10 @@ const OXYGEN_WORDMARK = [
 const LARGE_IMPORT_BACKGROUND_ROW_THRESHOLD = 500;
 const TABLE_ACTION_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_ACTION_RUN_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
+// Single-row paid runs are auto-backgrounded server-side; the CLI waits this
+// long for the cell to finish before handing back the queued run envelope.
+const SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS = 90;
+const SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_INTERVAL_SECONDS = 2;
 const TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
 const WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS = 600;
@@ -74,9 +78,28 @@ async function handleAsyncAction(command, options, action) {
     catch (error) {
         const failure = toFailure(command, error);
         writeJson(failure);
+        writeMaxCreditsHint(error);
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
+// Paid multi-row column runs require an explicit --max-credits spend cap; the
+// server rejects them with max_credits_required plus a recommended cap. Surface
+// that as a one-line stderr hint so users don't have to dig the value out of the
+// JSON envelope (stderr keeps --json stdout machine-clean).
+function writeMaxCreditsHint(error) {
+    if (!(error instanceof OxygenError) || error.code !== "max_credits_required")
+        return;
+    const recommended = readRecommendedMaxCredits(error.details);
+    if (recommended === null)
+        return;
+    process.stderr.write(`hint: re-run with --max-credits ${recommended} to approve the spend cap\n`);
+}
+function readRecommendedMaxCredits(details) {
+    if (!details || typeof details !== "object" || Array.isArray(details))
+        return null;
+    const value = details.recommended_max_credits;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function parseJsonObject(value) {
     let parsed;
     try {
@@ -479,6 +502,32 @@ export function createProgram() {
                 },
             });
         });
+    }))
+        .addCommand(new Command("backfill-upsert-indexes")
+        .description("Create missing upsert-key secondary indexes on customer tables. Staff only; defaults to dry-run.")
+        .option("--dry-run", "Report the index backfill plan without creating indexes. This is the default.")
+        .option("--apply", "Create the missing indexes (CONCURRENTLY). Requires --confirm.")
+        .option("--confirm", "Confirm --apply for index creation.")
+        .option("--org <id>", "Limit the backfill to a single organization id.")
+        .option("--limit <n>", "Maximum ready tenants to inspect in this batch. Defaults to 25; hard cap is 200.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("db backfill-upsert-indexes", options, () => {
+            if (options.apply && !options.confirm) {
+                throw new OxygenError("confirmation_required", "Refusing to create upsert-key indexes without --confirm.", { exitCode: 1 });
+            }
+            const limit = readPositiveInt(options.limit);
+            return requestOxygen("/api/cli/db/backfill-upsert-indexes", {
+                method: "POST",
+                body: {
+                    apply: Boolean(options.apply),
+                    dry_run: !options.apply,
+                    confirm: Boolean(options.confirm),
+                    ...(options.org ? { organization_id: options.org } : {}),
+                    ...(limit !== undefined ? { limit } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("cost-policy")
         .description("Show tenant database cost controls and reconciliation status.")
@@ -2017,28 +2066,31 @@ export function createProgram() {
     }));
     program
         .command("search")
-        .description("Agent-operable company search, web search, and scraping jobs.")
+        .description("Agent-operable people, signal, web, scrape, and local-business search jobs. For company search use 'oxygen companies search'.")
         .addCommand(new Command("plan")
         .description("Plan an Oxygen search or scrape route before running provider jobs.")
         .requiredOption("--goal <file|text>", "Search/scrape goal text, or a local file path containing the goal.")
-        .option("--kind <kind>", "Route kind: company_search, people_search, signal_search, web_search, web_scrape, local_business_search, or source_specific_scrape.")
+        .option("--kind <kind>", "Route kind: people_search, signal_search, web_search, web_scrape, local_business_search, or source_specific_scrape. For company search use 'oxygen companies search plan'.")
         .option("--target-count <n>", "Optional target row count.")
         .option("--geography <text>", "Optional geography hint.")
         .option("--known-urls <urls>", "Comma-separated known URLs for scrape routes.")
         .option("--provider-hints <providers>", "Comma-separated provider hints.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("search plan", options, () => requestOxygen("/api/cli/search/plan", {
-            method: "POST",
-            body: {
-                goal: readFileIfPresent(options.goal),
-                ...(readOption(options.kind) ? { kind: readOption(options.kind) } : {}),
-                ...(readPositiveInt(options.targetCount) ? { target_count: readPositiveInt(options.targetCount) } : {}),
-                ...(readOption(options.geography) ? { geography: readOption(options.geography) } : {}),
-                ...(readOption(options.knownUrls) ? { known_urls: readCsvOption(options.knownUrls) } : {}),
-                ...(readOption(options.providerHints) ? { provider_hints: readCsvOption(options.providerHints) } : {}),
-            },
-        }));
+        await handleAsyncAction("search plan", options, () => {
+            assertNotCompanySearchKind(options.kind);
+            return requestOxygen("/api/cli/search/plan", {
+                method: "POST",
+                body: {
+                    goal: readFileIfPresent(options.goal),
+                    ...(readOption(options.kind) ? { kind: readOption(options.kind) } : {}),
+                    ...(readPositiveInt(options.targetCount) ? { target_count: readPositiveInt(options.targetCount) } : {}),
+                    ...(readOption(options.geography) ? { geography: readOption(options.geography) } : {}),
+                    ...(readOption(options.knownUrls) ? { known_urls: readCsvOption(options.knownUrls) } : {}),
+                    ...(readOption(options.providerHints) ? { provider_hints: readCsvOption(options.providerHints) } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("run")
         .description("Preview or enqueue a durable table-backed search/scrape job from a search plan.")
@@ -2142,6 +2194,19 @@ export function createProgram() {
         .requiredOption("--prompt <text-or-file>", "Company-search prompt, or a path to a prompt file.")
         .option("--target-count <n>", "Desired company count for routing and estimates.")
         .option("--source-intent <intent>", "Override detected intent: sizing, structured, technology, hiring, local, known_source, concept, web, url, or fallback.")
+        .option("--filters-json <json-or-file>", "CompanySearchFilters JSON inline or a @file/path; wins over individual flags per top-level filter path.")
+        .option("--industries <csv>", "Comma-separated industries to include.")
+        .option("--exclude-industries <csv>", "Comma-separated industries to exclude.")
+        .option("--keywords <csv>", "Comma-separated keywords to include.")
+        .option("--exclude-keywords <csv>", "Comma-separated keywords to exclude.")
+        .option("--countries <csv>", "Comma-separated ISO 3166-1 alpha-2 country codes.")
+        .option("--employees <range>", "Employee count range: 20-200, 500+, or -50.")
+        .option("--funding-stages <csv>", "Comma-separated funding stages: pre_seed, seed, series_a, ...")
+        .option("--technologies <csv>", "Comma-separated technologies to include.")
+        .option("--revenue <range>", "Annual revenue (USD) range: 1000000-20000000, 1000000+, or -5000000.")
+        .option("--founded <range>", "Founded year range: 2015-2024, 2020+, or -2010.")
+        .option("--lookalike <csv>", "Comma-separated lookalike company domains.")
+        .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) => {
@@ -2163,6 +2228,19 @@ export function createProgram() {
         .option("--max-credits <n>", "Required credit ceiling for live runs.")
         .option("--target-count <n>", "Desired company count when planning from --prompt.")
         .option("--source-intent <intent>", "Override detected intent when planning from --prompt.")
+        .option("--filters-json <json-or-file>", "CompanySearchFilters JSON inline or a @file/path when planning from --prompt; wins over individual flags per top-level filter path.")
+        .option("--industries <csv>", "Comma-separated industries to include when planning from --prompt.")
+        .option("--exclude-industries <csv>", "Comma-separated industries to exclude when planning from --prompt.")
+        .option("--keywords <csv>", "Comma-separated keywords to include when planning from --prompt.")
+        .option("--exclude-keywords <csv>", "Comma-separated keywords to exclude when planning from --prompt.")
+        .option("--countries <csv>", "Comma-separated ISO 3166-1 alpha-2 country codes when planning from --prompt.")
+        .option("--employees <range>", "Employee count range when planning from --prompt: 20-200, 500+, or -50.")
+        .option("--funding-stages <csv>", "Comma-separated funding stages when planning from --prompt.")
+        .option("--technologies <csv>", "Comma-separated technologies to include when planning from --prompt.")
+        .option("--revenue <range>", "Annual revenue (USD) range when planning from --prompt.")
+        .option("--founded <range>", "Founded year range when planning from --prompt.")
+        .option("--lookalike <csv>", "Comma-separated lookalike company domains 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) => {
@@ -2416,7 +2494,11 @@ export function createProgram() {
         .description("Redacted operation event commands for the current organization.")
         .addCommand(new Command("events")
         .description("List recent redacted operation events and failures.")
-        .option("--status <status>", "Filter by completed, queued, completed_with_errors, or failed.")
+        // Keep in sync with OBSERVABILITY_STATUS_FILTERS in
+        // apps/web/src/lib/observability.ts and the MCP tool enum in
+        // packages/mcp-server/src/tools/observability.ts. The API rejects any
+        // other value with invalid_request so a typo fails loudly.
+        .option("--status <status>", "Filter by success, error, completed, failed, completed_with_errors, queued, skipped, or blocked.")
         .option("--trace-id <trace_id>", "Filter by trace id.")
         .option("--run-id <run_id>", "Filter by workspace run id.")
         .option("--limit <n>", "Maximum events to return. Defaults to 50.")
@@ -3010,6 +3092,348 @@ 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.")
+        .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, () => {
+            const params = new URLSearchParams();
+            if (options.usage !== false)
+                params.set("include_usage", "true");
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/accounts${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("connect")
+        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). Open the URL in a browser to complete authentication.")
+        .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, () => {
+            const reconnect = readOption(options.reconnect);
+            return requestOxygen("/api/cli/linkedin/accounts/connect", {
+                method: "POST",
+                body: {
+                    ...(reconnect ? { reconnect_connection_id: reconnect } : {}),
+                },
+            });
+        });
+    }))
+        .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.")
+        .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)}`));
+    }))
+        .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, () => {
+            const connectionId = readOption(options.connectionId);
+            return requestOxygen("/api/cli/linkedin/accounts/sync", {
+                method: "POST",
+                body: {
+                    ...(connectionId ? { connection_id: connectionId } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("disconnect")
+        .description("Disconnect a LinkedIn sender account so it stops sending. <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 disconnect", options, async () => requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/disconnect`, {
+            method: "POST",
+        }));
+    }))
+        .addCommand(new Command("limits")
+        .description("View and adjust per-account daily action limits and working hours.")
+        .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.")
+        .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`));
+    }))
+        .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.")
+        .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.")
+        .option("--messages-per-day <n>", "Daily direct messages cap.")
+        .option("--inmails-per-day <n>", "Daily InMail cap.")
+        .option("--profile-views-per-day <n>", "Daily profile views cap.")
+        .option("--follows-per-day <n>", "Daily follows cap.")
+        .option("--likes-per-day <n>", "Daily likes cap.")
+        .option("--total-actions-per-day <n>", "Daily cap across all send/action types.")
+        .option("--relations-reads-per-day <n>", "Daily cap on relations/connections list reads (scrape protection).")
+        .option("--messages-reads-per-day <n>", "Daily cap on chat and message-history reads.")
+        .option("--searches-per-day <n>", "Daily cap on LinkedIn search executions.")
+        .option("--api-reads-per-day <n>", "Daily cap on all other LinkedIn API reads.")
+        .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("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("linkedin accounts limits set", options, () => {
+            const body = buildLinkedinLimitsBody(options);
+            return requestOxygen(`/api/cli/linkedin/accounts/${encodeURIComponent(id)}/limits`, {
+                method: "PATCH",
+                body,
+            });
+        });
+    }))))
+        .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.")
+        .option("--account <id>", "Filter to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--unread", "Only show conversations with unread messages.")
+        .option("--search <text>", "Filter by attendee name or last-message text.")
+        .option("--include-archived", "Include archived conversations.")
+        .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, () => {
+            const params = new URLSearchParams();
+            const account = readOption(options.account);
+            if (account)
+                params.set("account", account);
+            if (options.unread)
+                params.set("unread", "true");
+            const search = readOption(options.search);
+            if (search)
+                params.set("search", search);
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/inbox${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one conversation with its full message thread. <conversation> accepts a conversation id or Unipile chat id.")
+        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .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, () => {
+            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}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("send")
+        .description("Reply into a LinkedIn conversation. Sends a real LinkedIn message — requires --approved. Without it, returns a preview.")
+        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .requiredOption("--text <message>", "Reply text to send.")
+        .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`, {
+            method: "POST",
+            body: {
+                text: readOption(options.text),
+                ...(options.approved ? { approved: true } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("mark-read")
+        .description("Mark a conversation and all its messages as read.")
+        .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`, {
+            method: "POST",
+        }));
+    }))
+        .addCommand(new Command("sync")
+        .description("Force a backstop inbox sync from Unipile for all active sender accounts (pulls recent chats + messages into the unibox).")
+        .option("--chat-limit <n>", "Maximum chats to sync per account. Defaults to 30.")
+        .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, () => {
+            const body = {};
+            const chatLimit = readOption(options.chatLimit);
+            if (chatLimit)
+                body.chat_limit = Number(chatLimit);
+            const messageLimit = readOption(options.messageLimit);
+            if (messageLimit)
+                body.message_limit = Number(messageLimit);
+            return requestOxygen("/api/cli/linkedin/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.")
+        .addCommand(new Command("list")
+        .description("List LinkedIn sequences with status 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, () => {
+            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}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("create")
+        .description("Create a draft sequence from a steps JSON file. Assign sender accounts with --senders.")
+        .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).")
+        .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("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin 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 maxCredits = readPositiveNumber(options.maxCredits);
+            return requestOxygen("/api/cli/linkedin/sequences", {
+                method: "POST",
+                body: {
+                    name: readOption(options.name),
+                    slug: readOption(options.slug),
+                    definition,
+                    senders,
+                    ...(readOption(options.table) ? { source_table_id: readOption(options.table) } : {}),
+                    ...(readOption(options.urlColumn) ? { linkedin_url_column_key: readOption(options.urlColumn) } : {}),
+                    ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                },
+            });
+        });
+    }))
+        .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)}`));
+    }))
+        .addCommand(new Command("enroll")
+        .description("Enroll leads into a sequence from a JSON file of { leads: [...] }. 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 }] }.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (sequence, options) => {
+        await handleAsyncAction("linkedin 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`, {
+                method: "POST",
+                body: { leads: parsed.leads ?? [] },
+            });
+        });
+    }))
+        .addCommand(new Command("start")
+        .description("Start a sequence. Dispatches REAL LinkedIn actions — requires --approved and --max-credits. Without them, returns a preview. Use --dry-run to activate in simulated mode (no sends, no credits).")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--approved", "Approve and activate live. Without this flag, returns a preview only.")
+        .option("--max-credits <n>", "Credit cap (required with --approved).")
+        .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, () => {
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            return requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/start`, {
+                method: "POST",
+                body: {
+                    ...(options.dryRun ? { dry_run: true } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                    ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("pause")
+        .description("Pause an active sequence (stops new dispatches; enrollments resume on un-pause).")
+        .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`, {
+            method: "POST", body: { status: "paused" },
+        }));
+    }))
+        .addCommand(new Command("resume")
+        .description("Resume a paused sequence.")
+        .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`, {
+            method: "POST", body: { status: "active" },
+        }));
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a sequence (terminal; cannot be reactivated).")
+        .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`, {
+            method: "POST", body: { status: "archived" },
+        }));
+    }))
+        .addCommand(new Command("enrollments")
+        .description("List a sequence's per-lead enrollments and their state.")
+        .argument("<sequence>", "Sequence id or slug.")
+        .option("--status <status>", "Filter by enrollment status (active, waiting_connection, replied, completed, stopped, failed).")
+        .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, () => {
+            const params = new URLSearchParams();
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/sequences/${encodeURIComponent(sequence)}/enrollments${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("stats")
+        .description("Show the sequence funnel: enrolled, invites sent, connected, replied, with acceptance and reply rates.")
+        .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`));
+    })));
     program
         .command("workflows")
         .description("Durable workflow automation commands.")
@@ -3849,21 +4273,94 @@ function tableRunsListPath(options) {
 }
 async function requestColumnsRun(body, table, options) {
     const traceId = randomUUID();
+    let result;
     try {
-        return await requestOxygen("/api/cli/tables/columns/run", {
+        result = await requestOxygen("/api/cli/tables/columns/run", {
             method: "POST",
             body,
             traceId,
         });
     }
     catch (error) {
-        if (!options.background || !isNetworkTimeoutError(error))
+        // Paid runs are durable background runs server-side (even single-row since
+        // v1.144.0), so a network timeout is always recoverable by locating the
+        // created run via its trace id - not only when --background was passed.
+        // Inline (formula) runs have no run to recover; recovery returns null and
+        // the original error propagates.
+        if (!isNetworkTimeoutError(error))
             throw error;
         const recovered = await recoverBackgroundColumnRun(table, traceId);
         if (!recovered)
             throw error;
         return recovered;
     }
+    // "Run this cell" still resolves to the finished value in one command: when
+    // the server auto-backgrounds a single-row paid run (caller did not pass
+    // --background), wait for the created run and attach its item output.
+    // Inline (formula) results carry no action_run_id and pass through as-is.
+    if (!options.background && typeof body.row_id === "string" && isRecord(result)) {
+        const actionRunId = readRecordString(result, "action_run_id");
+        if (actionRunId)
+            return resolveSingleRowColumnRun(result, actionRunId);
+    }
+    return result;
+}
+/**
+ * Wait for an auto-backgrounded single-row column run to finish and return the
+ * terminal run merged with its item output (the cell value). On wait timeout
+ * the queued run envelope is returned unchanged, plus the follow-up command -
+ * the run keeps executing server-side either way.
+ */
+async function resolveSingleRowColumnRun(envelope, actionRunId) {
+    const timeoutSeconds = readEnvPositiveInt("OXYGEN_COLUMN_RUN_WAIT_TIMEOUT_SECONDS")
+        ?? SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS;
+    const intervalSeconds = readEnvPositiveInt("OXYGEN_COLUMN_RUN_WAIT_INTERVAL_SECONDS")
+        ?? SINGLE_ROW_COLUMN_RUN_WAIT_DEFAULT_INTERVAL_SECONDS;
+    let waited;
+    try {
+        waited = await waitForTableActionRun(actionRunId, {
+            timeoutSeconds: String(timeoutSeconds),
+            intervalSeconds: String(intervalSeconds),
+        });
+    }
+    catch (error) {
+        if (error instanceof OxygenError && error.code === "table_action_run_wait_timeout") {
+            return {
+                ...envelope,
+                auto_wait_timed_out: true,
+                next_step: `oxygen table-runs wait ${actionRunId}`,
+            };
+        }
+        throw error;
+    }
+    const finalRun = isRecord(waited.actionRun) ? waited.actionRun : envelope;
+    const items = await listColumnRunItems(actionRunId);
+    return {
+        ...finalRun,
+        ...(items ? { items } : {}),
+        auto_waited: {
+            polls: waited.polls,
+            elapsed_ms: waited.elapsedMs,
+        },
+    };
+}
+async function listColumnRunItems(actionRunId) {
+    try {
+        const response = await requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(actionRunId)}/items?limit=5`);
+        const items = Array.isArray(response.items) ? response.items.filter(isRecord) : [];
+        return items.length > 0 ? items : null;
+    }
+    catch {
+        // The terminal run state is the answer; item output is best-effort.
+        return null;
+    }
+}
+function readEnvPositiveInt(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed >= 1 ? parsed : undefined;
 }
 async function recoverBackgroundColumnRun(table, traceId) {
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -3897,10 +4394,13 @@ function isNetworkTimeoutError(error) {
 }
 function readCompaniesSearchPlanBody(options) {
     const targetCount = readPositiveInt(options.targetCount);
+    const filters = readCompanySearchFilters(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 } : {}),
     };
 }
@@ -3913,6 +4413,7 @@ function readCompaniesSearchRunBody(options) {
     const maxPages = readPositiveInt(options.maxPages);
     const maxCredits = readPositiveNumber(options.maxCredits);
     const targetCount = readPositiveInt(options.targetCount);
+    const filters = prompt ? readCompanySearchFilters(options) : null;
     return {
         ...(prompt ? { prompt } : {}),
         ...(plan ? { plan } : {}),
@@ -3925,9 +4426,121 @@ function readCompaniesSearchRunBody(options) {
         ...(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 } : {}),
     };
 }
+// CompanySearchFilters mirror (structural — the server validates the shape). Builds a
+// filters object from individual --industries/--countries/--employees/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 readCompanySearchFilters(options) {
+    const filters = {};
+    const industries = readIncludeExclude(options.industries, options.excludeIndustries);
+    if (industries)
+        filters.industries = industries;
+    const keywords = readIncludeExclude(options.keywords, options.excludeKeywords);
+    if (keywords)
+        filters.keywords = keywords;
+    const countries = readCsvOption(options.countries);
+    if (countries.length > 0)
+        filters.geo = { countries };
+    const employeeCount = readRangeOption(options.employees, "--employees");
+    if (employeeCount)
+        filters.employee_count = employeeCount;
+    const fundingStages = readCsvOption(options.fundingStages);
+    if (fundingStages.length > 0)
+        filters.funding = { stages: fundingStages };
+    const technologies = readIncludeExclude(options.technologies, undefined);
+    if (technologies)
+        filters.technologies = technologies;
+    const revenue = readRangeOption(options.revenue, "--revenue");
+    if (revenue)
+        filters.revenue_usd = revenue;
+    const founded = readRangeOption(options.founded, "--founded");
+    if (founded)
+        filters.founded_year = founded;
+    const lookalike = readCsvOption(options.lookalike);
+    if (lookalike.length > 0)
+        filters.lookalike_domains = lookalike;
+    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 readIncludeExclude(include, exclude) {
+    const includeValues = readCsvOption(include);
+    const excludeValues = readCsvOption(exclude);
+    const result = {};
+    if (includeValues.length > 0)
+        result.include = includeValues;
+    if (excludeValues.length > 0)
+        result.exclude = excludeValues;
+    return Object.keys(result).length > 0 ? result : null;
+}
+// Range flags accept "20-200" -> { min, max }, "500+" -> { min }, "-50" -> { max },
+// and a bare "200" -> { min, max } (exact value).
+function readRangeOption(value, flag) {
+    const raw = readOption(value);
+    if (!raw)
+        return null;
+    if (/^\d+\+$/.test(raw)) {
+        return { min: readRangeNumber(raw.slice(0, -1), flag, raw) };
+    }
+    if (/^-\d+$/.test(raw)) {
+        return { max: readRangeNumber(raw.slice(1), flag, raw) };
+    }
+    if (/^\d+-\d+$/.test(raw)) {
+        const [minRaw, maxRaw] = raw.split("-");
+        const min = readRangeNumber(minRaw, flag, raw);
+        const max = readRangeNumber(maxRaw, flag, raw);
+        if (min > max) {
+            throw new OxygenError("invalid_range", `${flag} min must not exceed max.`, {
+                details: { flag, value: raw },
+                exitCode: 1,
+            });
+        }
+        return { min, max };
+    }
+    if (/^\d+$/.test(raw)) {
+        const bound = readRangeNumber(raw, flag, raw);
+        return { min: bound, max: bound };
+    }
+    throw new OxygenError("invalid_range", `${flag} expects a range like 20-200, 500+, or -50.`, {
+        details: { flag, value: raw },
+        exitCode: 1,
+    });
+}
+function readRangeNumber(value, flag, raw) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new OxygenError("invalid_range", `${flag} bounds must be non-negative integers.`, {
+            details: { flag, value: raw },
+            exitCode: 1,
+        });
+    }
+    return parsed;
+}
+// Company search has moved to the dedicated companies-search surface. The CLI rejects
+// `oxygen search plan --kind company_search` client-side so a stale agent gets a typed,
+// self-correcting error instead of an opaque server 400. Message mirrors
+// COMPANY_SEARCH_MOVED_MESSAGE in @oxygen/tools (CLI does not import that package).
+const COMPANY_SEARCH_MOVED_MESSAGE = "Company search is handled by the dedicated companies-search surface. Use: oxygen companies search plan --prompt \"<goal>\" (CLI) or oxygen_companies_search_plan (MCP).";
+function assertNotCompanySearchKind(kind) {
+    if (readOption(kind) === "company_search") {
+        throw new OxygenError("use_companies_search", COMPANY_SEARCH_MOVED_MESSAGE, {
+            details: {
+                equivalent_cli: "oxygen companies search plan --prompt <goal>",
+                equivalent_mcp: "oxygen_companies_search_plan",
+            },
+            exitCode: 1,
+        });
+    }
+}
 function readCompanySearchPlanJson(value) {
     const parsed = parseJsonObject(readFileIfPresent(value));
     const data = parsed.data;
@@ -6306,6 +6919,67 @@ 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.
+options) {
+    const limits = {};
+    const setLimit = (key, value) => {
+        const parsed = readNonNegativeInt(value);
+        if (parsed !== undefined)
+            limits[key] = parsed;
+    };
+    setLimit("invites_per_day", options.invitesPerDay);
+    setLimit("invites_per_week", options.invitesPerWeek);
+    setLimit("messages_per_day", options.messagesPerDay);
+    setLimit("inmails_per_day", options.inmailsPerDay);
+    setLimit("profile_views_per_day", options.profileViewsPerDay);
+    setLimit("follows_per_day", options.followsPerDay);
+    setLimit("likes_per_day", options.likesPerDay);
+    setLimit("total_actions_per_day", options.totalActionsPerDay);
+    setLimit("relations_reads_per_day", options.relationsReadsPerDay);
+    setLimit("messages_reads_per_day", options.messagesReadsPerDay);
+    setLimit("searches_per_day", options.searchesPerDay);
+    setLimit("api_reads_per_day", options.apiReadsPerDay);
+    setLimit("total_reads_per_day", options.totalReadsPerDay);
+    setLimit("min_action_spacing_seconds", options.minSpacingSeconds);
+    setLimit("action_spacing_jitter_seconds", options.spacingJitterSeconds);
+    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 });
+    }
+    return {
+        ...(hasLimits ? { limits } : {}),
+        ...(hasWorkingHours ? { working_hours: workingHours } : {}),
+    };
+}
 function readPositiveInt(value) {
     const trimmed = value?.trim();
     if (!trimmed)