@oxygen-agent/cli 1.146.1 → 1.152.15

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation and support, visit https://oxygen-agent.com.
 
-Version: 1.146.1
+Version: 1.152.15

package/dist/http-client.js

@@ -86,9 +86,10 @@ path, options = {}) {
     if (!response.ok || !envelope.ok) {
         const failure = envelope;
         const responseTraceId = response.headers.get("x-oxygen-trace-id") ?? traceId;
+        const details = withRetryAfterDetails(failure.error.details, response);
         throw new OxygenError(failure.error.code, failure.error.message, {
-            details: withTraceDetails(failure.error.details, responseTraceId, compatibility, apiUrl),
-            exitCode: response.status >= 500 ? 1 : 1,
+            details: withTraceDetails(details, responseTraceId, compatibility, apiUrl),
+            exitCode: 1,
         });
     }
     return envelope.data;
@@ -200,6 +201,43 @@ function readEnvelopeCompatibility(envelope) {
     }
     return compatibility;
 }
+// Surface the server's 429 backoff as a first-class `retry_after_seconds` detail
+// so loop-driving callers can wait the right amount of time instead of dead-
+// reckoning. Prefers a value the API already put in details; otherwise derives
+// it from the RFC 6585 Retry-After header (or reset_at). Non-429 responses and
+// unparseable values pass through untouched.
+function withRetryAfterDetails(details, response) {
+    if (response.status !== 429)
+        return details;
+    const record = details && typeof details === "object" && !Array.isArray(details)
+        ? details
+        : null;
+    if (record && typeof record.retry_after_seconds === "number")
+        return details;
+    const retryAfterSeconds = retryAfterSecondsFromResponse(response, record);
+    if (retryAfterSeconds === null)
+        return details;
+    if (record)
+        return { ...record, retry_after_seconds: retryAfterSeconds };
+    if (details === undefined)
+        return { retry_after_seconds: retryAfterSeconds };
+    return { details, retry_after_seconds: retryAfterSeconds };
+}
+function retryAfterSecondsFromResponse(response, details) {
+    const header = response.headers.get("retry-after");
+    if (header) {
+        const seconds = Number(header);
+        if (Number.isFinite(seconds) && seconds >= 0)
+            return Math.ceil(seconds);
+    }
+    const resetAt = details?.reset_at;
+    if (typeof resetAt === "string") {
+        const resetMs = Date.parse(resetAt);
+        if (!Number.isNaN(resetMs))
+            return Math.max(0, Math.ceil((resetMs - Date.now()) / 1000));
+    }
+    return null;
+}
 function withTraceDetails(details, traceId, compatibility, apiUrl) {
     const serverVersion = compatibility.version;
     const fields = {

package/dist/index.js

@@ -2066,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.")
@@ -2191,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) => {
@@ -2212,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) => {
@@ -3151,7 +3180,12 @@ export function createProgram() {
         .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 action types.")
+        .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.")
@@ -3253,6 +3287,152 @@ export function createProgram() {
                 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")
@@ -4214,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 } : {}),
     };
 }
@@ -4230,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 } : {}),
@@ -4242,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;
@@ -6654,6 +6950,11 @@ options) {
     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 = {};

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -4,10 +4,12 @@ export * from "./billing.js";
 export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
+export * from "./linkedin-sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
 export * from "./telemetry.js";
+export declare const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };

package/node_modules/@oxygen/shared/dist/index.js

@@ -5,10 +5,17 @@ export * from "./billing.js";
 export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
+export * from "./linkedin-sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
 export * from "./telemetry.js";
+// Maximum rows a single row-loop write (insert/upsert/preview) may process. The
+// row-loop engine issues one DB round-trip per row, so a 500-row write already
+// approaches request timeouts (~50s observed in prod); larger batches must use
+// the COPY-based bulk engine. Tenant-db enforces this and the CLI/API row caps
+// reference it so they never advertise a batch the row-loop will reject.
+export const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export class OxygenError extends Error {
     code;
     details;

package/node_modules/@oxygen/shared/dist/linkedin-sequences.d.ts

@@ -0,0 +1,83 @@
+/**
+ * LinkedIn sequence step schema — the shared contract validated identically by
+ * CLI, MCP, API, and web. A sequence is an ordered list of steps applied to
+ * each enrolled lead; the worker dispatch engine materializes one
+ * sequence_action per step as it comes due.
+ *
+ * Step kinds:
+ * - visit_profile        — view the lead's profile (warms up before an invite)
+ * - invite               — send a connection request, optional note_template
+ * - wait_for_connection  — gate: wait until the invite is accepted (new_relation
+ *                          webhook) or timeout_days elapses; on timeout stop or
+ *                          continue per on_timeout
+ * - wait                 — fixed delay (days/hours) before the next step
+ * - message              — send a message (opens a chat if none exists);
+ *                          template supports {{column}} interpolation
+ * - inmail               — send an InMail (works on non-connections); subject +
+ *                          template
+ */
+export declare const LINKEDIN_SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "wait", "message", "inmail"];
+export type LinkedInSequenceStepKind = typeof LINKEDIN_SEQUENCE_STEP_KINDS[number];
+export type LinkedInVisitProfileStep = {
+    kind: "visit_profile";
+};
+export type LinkedInInviteStep = {
+    kind: "invite";
+    /** Optional connection-request note. Supports {{column}} interpolation. ~300 char max on LinkedIn. */
+    note_template?: string;
+};
+export type LinkedInWaitForConnectionStep = {
+    kind: "wait_for_connection";
+    /** Days to wait for the invite to be accepted before acting on on_timeout. */
+    timeout_days: number;
+    /** What to do if the invite is never accepted. Defaults to "stop". */
+    on_timeout?: "stop" | "continue";
+};
+export type LinkedInWaitStep = {
+    kind: "wait";
+    /** Fixed delay before the next step. Provide days and/or hours (>= 1 total). */
+    days?: number;
+    hours?: number;
+};
+export type LinkedInMessageStep = {
+    kind: "message";
+    /** Message body. Supports {{column}} interpolation from the source-table row. */
+    template: string;
+};
+export type LinkedInInMailStep = {
+    kind: "inmail";
+    subject_template: string;
+    template: string;
+};
+export type LinkedInSequenceStep = LinkedInVisitProfileStep | LinkedInInviteStep | LinkedInWaitForConnectionStep | LinkedInWaitStep | LinkedInMessageStep | LinkedInInMailStep;
+export type LinkedInSequenceDefinition = {
+    steps: LinkedInSequenceStep[];
+};
+/**
+ * The dispatch-queue action kind a step produces (matches the
+ * ox_linkedin.sequence_actions.action_kind enum), or null for gate/wait steps
+ * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
+ * — visit_profile maps to the quota kind profile_view downstream.
+ */
+export declare const LINKEDIN_STEP_ACTION_KIND: Record<LinkedInSequenceStepKind, "visit_profile" | "invite" | "message" | "inmail" | null>;
+export type LinkedInSequenceLintIssue = {
+    path: string;
+    message: string;
+};
+/**
+ * Validate a raw sequence definition. Returns the normalized definition or
+ * throws OxygenError("invalid_linkedin_sequence") with per-step issues. Pure —
+ * safe to call from any surface.
+ */
+export declare function validateLinkedInSequenceDefinition(input: unknown): LinkedInSequenceDefinition;
+/** Non-throwing variant for lint surfaces. */
+export declare function lintLinkedInSequenceDefinition(input: unknown): LinkedInSequenceLintIssue[];
+/** Total delay in milliseconds a `wait` step introduces. */
+export declare function waitStepDelayMs(step: LinkedInWaitStep): number;
+/**
+ * Render a {{column}} template against a row's values. Unknown placeholders
+ * render empty. Used by the dispatch engine to produce the final message text.
+ */
+export declare function renderLinkedInTemplate(template: string, values: Record<string, unknown>): string;
+/** Column keys referenced by {{...}} placeholders across all steps. */
+export declare function linkedInTemplateVariables(definition: LinkedInSequenceDefinition): string[];

package/node_modules/@oxygen/shared/dist/linkedin-sequences.js

@@ -0,0 +1,268 @@
+import { OxygenError } from "./index.js";
+/**
+ * LinkedIn sequence step schema — the shared contract validated identically by
+ * CLI, MCP, API, and web. A sequence is an ordered list of steps applied to
+ * each enrolled lead; the worker dispatch engine materializes one
+ * sequence_action per step as it comes due.
+ *
+ * Step kinds:
+ * - visit_profile        — view the lead's profile (warms up before an invite)
+ * - invite               — send a connection request, optional note_template
+ * - wait_for_connection  — gate: wait until the invite is accepted (new_relation
+ *                          webhook) or timeout_days elapses; on timeout stop or
+ *                          continue per on_timeout
+ * - wait                 — fixed delay (days/hours) before the next step
+ * - message              — send a message (opens a chat if none exists);
+ *                          template supports {{column}} interpolation
+ * - inmail               — send an InMail (works on non-connections); subject +
+ *                          template
+ */
+export const LINKEDIN_SEQUENCE_STEP_KINDS = [
+    "visit_profile",
+    "invite",
+    "wait_for_connection",
+    "wait",
+    "message",
+    "inmail",
+];
+/**
+ * The dispatch-queue action kind a step produces (matches the
+ * ox_linkedin.sequence_actions.action_kind enum), or null for gate/wait steps
+ * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
+ * — visit_profile maps to the quota kind profile_view downstream.
+ */
+export const LINKEDIN_STEP_ACTION_KIND = {
+    visit_profile: "visit_profile",
+    invite: "invite",
+    wait_for_connection: null,
+    wait: null,
+    message: "message",
+    inmail: "inmail",
+};
+const MAX_STEPS = 25;
+const MAX_TEMPLATE_LENGTH = 8_000;
+const MAX_NOTE_LENGTH = 300;
+/**
+ * Validate a raw sequence definition. Returns the normalized definition or
+ * throws OxygenError("invalid_linkedin_sequence") with per-step issues. Pure —
+ * safe to call from any surface.
+ */
+export function validateLinkedInSequenceDefinition(input) {
+    const issues = [];
+    const steps = collectSteps(input, issues);
+    const normalized = [];
+    steps.forEach((rawStep, index) => {
+        const step = normalizeStep(rawStep, index, issues);
+        if (step)
+            normalized.push(step);
+    });
+    validateStructure(normalized, issues);
+    if (issues.length > 0) {
+        throw new OxygenError("invalid_linkedin_sequence", `Sequence definition is invalid: ${issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`, { details: { issues }, exitCode: 1 });
+    }
+    return { steps: normalized };
+}
+/** Non-throwing variant for lint surfaces. */
+export function lintLinkedInSequenceDefinition(input) {
+    try {
+        validateLinkedInSequenceDefinition(input);
+        return [];
+    }
+    catch (error) {
+        if (error instanceof OxygenError && error.details && typeof error.details === "object") {
+            const issues = error.details.issues;
+            if (Array.isArray(issues))
+                return issues;
+        }
+        return [{ path: "steps", message: error instanceof Error ? error.message : "Invalid sequence." }];
+    }
+}
+function collectSteps(input, issues) {
+    const record = isRecord(input) ? input : null;
+    const steps = record?.steps;
+    if (!Array.isArray(steps)) {
+        issues.push({ path: "steps", message: "steps must be an array." });
+        return [];
+    }
+    if (steps.length === 0) {
+        issues.push({ path: "steps", message: "A sequence needs at least one step." });
+    }
+    if (steps.length > MAX_STEPS) {
+        issues.push({ path: "steps", message: `A sequence may have at most ${MAX_STEPS} steps.` });
+    }
+    return steps;
+}
+function normalizeStep(// skipcq: JS-R1005 -- step normalization validates a discriminated sequence DSL with per-step fields.
+raw, index, issues) {
+    const path = `steps[${index}]`;
+    if (!isRecord(raw)) {
+        issues.push({ path, message: "Each step must be an object." });
+        return null;
+    }
+    const kind = raw.kind;
+    if (typeof kind !== "string" || !LINKEDIN_SEQUENCE_STEP_KINDS.includes(kind)) {
+        issues.push({
+            path: `${path}.kind`,
+            message: `kind must be one of: ${LINKEDIN_SEQUENCE_STEP_KINDS.join(", ")}.`,
+        });
+        return null;
+    }
+    switch (kind) {
+        case "visit_profile":
+            return { kind: "visit_profile" };
+        case "invite": {
+            const note = optionalTemplate(raw.note_template, `${path}.note_template`, MAX_NOTE_LENGTH, issues);
+            return note !== undefined ? { kind: "invite", note_template: note } : { kind: "invite" };
+        }
+        case "wait_for_connection": {
+            // timeout_days is optional (defaults to 14); only validate when provided.
+            const timeoutDays = raw.timeout_days === undefined || raw.timeout_days === null
+                ? undefined
+                : positiveInt(raw.timeout_days, `${path}.timeout_days`, issues);
+            const onTimeout = raw.on_timeout;
+            if (onTimeout !== undefined && onTimeout !== "stop" && onTimeout !== "continue") {
+                issues.push({ path: `${path}.on_timeout`, message: "on_timeout must be 'stop' or 'continue'." });
+            }
+            return {
+                kind: "wait_for_connection",
+                timeout_days: timeoutDays ?? 14,
+                on_timeout: onTimeout === "continue" ? "continue" : "stop",
+            };
+        }
+        case "wait": {
+            const days = optionalNonNegativeInt(raw.days, `${path}.days`, issues);
+            const hours = optionalNonNegativeInt(raw.hours, `${path}.hours`, issues);
+            if ((days ?? 0) + (hours ?? 0) <= 0) {
+                issues.push({ path, message: "A wait step needs days and/or hours totaling at least 1 hour." });
+            }
+            return {
+                kind: "wait",
+                ...(days !== undefined ? { days } : {}),
+                ...(hours !== undefined ? { hours } : {}),
+            };
+        }
+        case "message": {
+            const template = requiredTemplate(raw.template, `${path}.template`, issues);
+            return { kind: "message", template: template ?? "" };
+        }
+        case "inmail": {
+            const subject = requiredTemplate(raw.subject_template, `${path}.subject_template`, issues);
+            const template = requiredTemplate(raw.template, `${path}.template`, issues);
+            return { kind: "inmail", subject_template: subject ?? "", template: template ?? "" };
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Structural rules across steps:
+ * - The first send step must be invite or visit_profile (you can't message a
+ *   stranger without connecting); a message before any invite/wait_for_connection
+ *   is valid for warm lists whose leads are already 1st-degree connections.
+ * - wait_for_connection must be preceded by an invite.
+ * - Two consecutive wait/wait_for_connection steps are pointless.
+ */
+function validateStructure(steps, issues) {
+    let sawInvite = false;
+    steps.forEach((step, index) => {
+        if (step.kind === "invite")
+            sawInvite = true;
+        if (step.kind === "wait_for_connection" && !sawInvite) {
+            issues.push({
+                path: `steps[${index}]`,
+                message: "wait_for_connection must come after an invite step.",
+            });
+        }
+        if (step.kind === "message" && !sawInvite && !steps.slice(0, index).some((s) => s.kind === "wait_for_connection")) {
+            // A message before connecting only works for existing 1st-degree
+            // connections. This is valid for warm lists; do not add a fatal issue
+            // until the API has a separate warning channel.
+        }
+    });
+}
+function requiredTemplate(value, path, issues) {
+    if (typeof value !== "string" || !value.trim()) {
+        issues.push({ path, message: "is required and must be a non-empty string." });
+        return undefined;
+    }
+    if (value.length > MAX_TEMPLATE_LENGTH) {
+        issues.push({ path, message: `must be at most ${MAX_TEMPLATE_LENGTH} characters.` });
+        return undefined;
+    }
+    return value;
+}
+function optionalTemplate(value, path, maxLength, issues) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string") {
+        issues.push({ path, message: "must be a string." });
+        return undefined;
+    }
+    if (value.length > maxLength) {
+        issues.push({ path, message: `must be at most ${maxLength} characters.` });
+        return undefined;
+    }
+    return value;
+}
+function positiveInt(value, path, issues) {
+    const num = Number(value);
+    if (!Number.isInteger(num) || num <= 0) {
+        issues.push({ path, message: "must be a positive integer." });
+        return undefined;
+    }
+    return num;
+}
+function optionalNonNegativeInt(value, path, issues) {
+    if (value === undefined || value === null)
+        return undefined;
+    const num = Number(value);
+    if (!Number.isInteger(num) || num < 0) {
+        issues.push({ path, message: "must be a non-negative integer." });
+        return undefined;
+    }
+    return num;
+}
+/** Total delay in milliseconds a `wait` step introduces. */
+export function waitStepDelayMs(step) {
+    const days = step.days ?? 0;
+    const hours = step.hours ?? 0;
+    return (days * 24 + hours) * 60 * 60 * 1000;
+}
+/**
+ * Render a {{column}} template against a row's values. Unknown placeholders
+ * render empty. Used by the dispatch engine to produce the final message text.
+ */
+export function renderLinkedInTemplate(template, values) {
+    return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_match, key) => {
+        const value = values[key];
+        if (value === null || value === undefined)
+            return "";
+        return typeof value === "string" ? value : String(value);
+    });
+}
+/** Column keys referenced by {{...}} placeholders across all steps. */
+export function linkedInTemplateVariables(definition) {
+    const vars = new Set();
+    const scan = (template) => {
+        if (!template)
+            return;
+        for (const match of template.matchAll(/\{\{\s*([\w.]+)\s*\}\}/g)) {
+            if (match[1])
+                vars.add(match[1]);
+        }
+    };
+    for (const step of definition.steps) {
+        if (step.kind === "invite")
+            scan(step.note_template);
+        if (step.kind === "message")
+            scan(step.template);
+        if (step.kind === "inmail") {
+            scan(step.subject_template);
+            scan(step.template);
+        }
+    }
+    return [...vars];
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/node_modules/@oxygen/shared/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const OXYGEN_VERSION = "1.146.1";
+export declare const OXYGEN_VERSION = "1.152.15";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.135.0";

package/node_modules/@oxygen/shared/dist/version.js

@@ -1,3 +1,3 @@
-export const OXYGEN_VERSION = "1.146.1";
+export const OXYGEN_VERSION = "1.152.15";
 // Bump this only when deployed CLI/API contracts require a newer CLI.
 export const OXYGEN_MINIMUM_CLI_VERSION = "1.135.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.146.1",
+  "version": "1.152.15",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",