@oxygen-agent/cli 1.226.15 → 1.242.6

package/dist/index.js

@@ -1,8 +1,8 @@
 import { execFileSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, dirname, extname, resolve } from "node:path";
+import { basename, dirname, extname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -337,6 +337,21 @@ function readFileIfPresent(value) {
         throw error;
     }
 }
+// `--suppress-list <comma ids or @file>`: a comma-separated list of lead provider
+// ids, or `@<path>` to a file of ids (comma/newline/whitespace separated). Returns
+// the trimmed, de-duplicated, blank-free ids; an absent value yields an empty list.
+function parseSuppressListOption(value) {
+    const raw = readOption(value);
+    if (!raw)
+        return [];
+    const text = raw.startsWith("@") ? readFileSync(resolve(raw.slice(1)), "utf8") : raw;
+    return [
+        ...new Set(text
+            .split(/[\s,]+/)
+            .map((id) => id.trim())
+            .filter((id) => id.length > 0)),
+    ];
+}
 function resolveComposioRunMode(options) {
     if (options.live === true && options.dryRun === true) {
         throw new OxygenError("conflicting_flags", "Pass either --live or --dry-run, not both.", { exitCode: 1 });
@@ -428,9 +443,66 @@ function buildCrmSyncImportBody(provider, options) {
         ...(options.approved ? { approved: true } : {}),
     };
 }
-function buildCrmSyncStatusPath(runId) {
+function buildCrmSyncConfigureBody(options) {
+    return {
+        provider: options.provider,
+        object: options.object,
+        mode: resolveCrmSetupMode(options),
+        ...(readOption(options.direction) ? { direction: readOption(options.direction) } : {}),
+        ...(readOption(options.cron) ? { cron: readOption(options.cron) } : {}),
+        ...(readOption(options.timezone) ? { timezone: readOption(options.timezone) } : {}),
+        ...(readPositiveInt(options.maxRows) !== undefined ? { max_rows_per_cycle: readPositiveInt(options.maxRows) } : {}),
+        ...(readPositiveNumber(options.maxCredits) !== undefined ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+        ...(options.approved ? { approved: true } : {}),
+    };
+}
+function buildCrmSyncRunBody(options) {
+    return {
+        provider: options.provider,
+        object: options.object,
+        mode: resolveCrmSetupMode(options),
+        ...(readPositiveInt(options.maxRows) !== undefined ? { max_rows_per_cycle: readPositiveInt(options.maxRows) } : {}),
+        ...(readPositiveNumber(options.maxCredits) !== undefined ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+        ...(options.approved ? { approved: true } : {}),
+    };
+}
+function buildCrmSyncEnableBody(options) {
+    return {
+        provider: options.provider,
+        object: options.object,
+        ...(readOption(options.direction) ? { direction: readOption(options.direction) } : {}),
+        ...(readOption(options.cron) ? { cron: readOption(options.cron) } : {}),
+        ...(readOption(options.timezone) ? { timezone: readOption(options.timezone) } : {}),
+        ...(readPositiveInt(options.maxRows) !== undefined ? { max_rows_per_cycle: readPositiveInt(options.maxRows) } : {}),
+        ...(readPositiveNumber(options.maxCredits) !== undefined ? { max_credits: readPositiveNumber(options.maxCredits) } : {}),
+        ...(options.approved ? { approved: true } : {}),
+        // Commander maps --no-run-now to runNow:false (default true); only send the
+        // opt-out so the route's default (run an immediate first cycle) holds.
+        ...(options.runNow === false ? { run_now: false } : {}),
+    };
+}
+function buildCrmSyncDisableBody(options) {
+    return { provider: options.provider, object: options.object };
+}
+function buildCrmSyncConfigStatusPath(options) {
+    const runId = readOption(options.runId);
+    const provider = readOption(options.provider);
+    const object = readOption(options.object);
+    const hasPair = provider !== null && object !== null;
+    if (runId !== null && (provider !== null || object !== null)) {
+        throw new OxygenError("conflicting_flags", "Pass either --run-id or --provider/--object, not both.", { exitCode: 1 });
+    }
+    if (runId === null && !hasPair) {
+        throw new OxygenError("missing_target", "Pass --run-id for a single run, or --provider and --object for a standing sync config.", { exitCode: 1 });
+    }
     const params = new URLSearchParams();
-    params.set("run_id", runId);
+    if (runId !== null) {
+        params.set("run_id", runId);
+    }
+    else {
+        params.set("provider", provider);
+        params.set("object", object);
+    }
     return `/api/cli/crm/sync/status?${params.toString()}`;
 }
 function buildCrmSyncLinksPath(object, rowId) {
@@ -563,6 +635,56 @@ function buildCrmDuplicatesPath(object, options) {
     const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/duplicates`;
     return query ? `${base}?${query}` : base;
 }
+function buildCrmSignalRecordBody(options) {
+    const event = readOption(options.event);
+    if (!event) {
+        throw new OxygenError("invalid_request", "--event is required.", { exitCode: 1 });
+    }
+    const sessionId = readOption(options.sessionId);
+    // The redelivery/idempotency guard: an explicit id, else derived from the
+    // provider session id so a repeat reveal still dedupes.
+    const externalEventId = readOption(options.externalEventId) ?? (sessionId ? `signal:${sessionId}` : null);
+    if (!externalEventId) {
+        throw new OxygenError("invalid_request", "--external-event-id is required (or pass --session-id to derive it).", { exitCode: 1 });
+    }
+    const payload = {};
+    const email = readOption(options.email);
+    if (email)
+        payload.email = email;
+    const linkedinUrl = readOption(options.linkedinUrl);
+    if (linkedinUrl)
+        payload.linkedin_url = linkedinUrl;
+    const companyDomain = readOption(options.companyDomain);
+    if (companyDomain)
+        payload.company_domain = companyDomain;
+    const companyName = readOption(options.companyName);
+    if (companyName)
+        payload.company_name = companyName;
+    const firstName = readOption(options.firstName);
+    if (firstName)
+        payload.first_name = firstName;
+    const lastName = readOption(options.lastName);
+    if (lastName)
+        payload.last_name = lastName;
+    const pageUrl = readOption(options.pageUrl);
+    if (pageUrl)
+        payload.page_url = pageUrl;
+    if (sessionId)
+        payload.session_id = sessionId;
+    // An explicit --payload-json wins over the convenience flags above.
+    if (options.payloadJson)
+        Object.assign(payload, parseJsonObject(options.payloadJson));
+    return { event, external_event_id: externalEventId, payload };
+}
+function buildCrmLeadsTodayPath(options) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", options.limit);
+    if (options.withinDays)
+        params.set("within_days", options.withinDays);
+    const query = params.toString();
+    return query ? `/api/cli/crm/signals/leads-today?${query}` : "/api/cli/crm/signals/leads-today";
+}
 function buildCrmAutomationSetBody(templateId, options) {
     if (options.armed === true && options.disarmed === true) {
         throw new OxygenError("conflicting_flags", "Pass either --armed or --disarmed, not both.", { exitCode: 1 });
@@ -1531,6 +1653,36 @@ export function createProgram() {
         .action(async (options) => {
         await handleAsyncAction("crm pipeline", options, () => requestOxygen(buildCrmPipelinePath(options)));
     }))
+        .addCommand(new Command("signals")
+        .description("Record inbound GTM intent signals and read the ranked leads-to-contact-today list.")
+        .addCommand(new Command("record")
+        .description("Record one inbound GTM signal (website_visit, profile_view, post_engager, new_follower) into the CRM. Internal write — free, no approval. Idempotent on --external-event-id.")
+        .requiredOption("--event <event>", "Signal event: website_visit | profile_view | post_engager | new_follower.")
+        .option("--external-event-id <id>", "Stable provider event id (redelivery/idempotency guard). Derived from --session-id when omitted.")
+        .option("--email <email>", "Person email (identity).")
+        .option("--linkedin-url <url>", "Person LinkedIn URL (identity when no email).")
+        .option("--company-domain <domain>", "Company domain for the company assert.")
+        .option("--company-name <name>", "Company name.")
+        .option("--first-name <name>", "Person first name.")
+        .option("--last-name <name>", "Person last name.")
+        .option("--page-url <url>", "Page the signal fired on (website visit).")
+        .option("--session-id <id>", "Provider session id (provenance + idempotency).")
+        .option("--payload-json <json>", "JSON object merged into the signal payload (wins over the flags above).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm signals record", options, () => requestOxygen("/api/cli/crm/signals", {
+            method: "POST",
+            body: buildCrmSignalRecordBody(options),
+        }));
+    }))
+        .addCommand(new Command("leads-today")
+        .description("List people to contact today, ranked by their most recent GTM intent signal. Do-not-contact filtering is best-effort (email-only leads surface unchecked).")
+        .option("--limit <limit>", "Maximum leads to return. Defaults to 25, max 100.")
+        .option("--within-days <days>", "Signal look-back window in days. Defaults to 7, max 30.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm signals leads-today", options, () => requestOxygen(buildCrmLeadsTodayPath(options)));
+    })))
         .addCommand(new Command("lists")
         .description("Static and dynamic CRM lists over companies, people, deals, and custom objects.")
         .addCommand(new Command("create")
@@ -1625,7 +1777,7 @@ export function createProgram() {
         await handleAsyncAction("crm automation audit", options, () => requestOxygen(buildCrmAutomationAuditPath(options)));
     })))
         .addCommand(new Command("sync")
-        .description("Import records from a connected CRM (HubSpot/Attio) into Oxygen CRM objects, and inspect import runs and provider links.")
+        .description("Bidirectionally sync a connected CRM (HubSpot/Attio) with Oxygen CRM objects: import records, configure a standing two-way sync, run a reconciliation cycle, and inspect runs and provider links.")
         .addCommand(new Command("import")
         .description("Import provider records into an Oxygen CRM object as a durable workflow run. Defaults to dry-run.")
         .argument("<provider>", "Connected CRM to import from: hubspot or attio.")
@@ -1642,13 +1794,84 @@ export function createProgram() {
             method: "POST",
             body: buildCrmSyncImportBody(provider, options),
         }));
+    }))
+        .addCommand(new Command("configure")
+        .description("Configure a standing bidirectional sync for one CRM object pair. Defaults to dry-run, which returns a real preview of the next cycle.")
+        .requiredOption("--provider <provider>", "Connected CRM: hubspot or attio.")
+        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, or attio people|companies.")
+        .option("--direction <direction>", "Sync direction: inbound, outbound, or bidirectional. Defaults to bidirectional.")
+        .option("--cron <cron>", "Cron expression for the scheduled reconciliation cadence, e.g. '*/15 * * * *'.")
+        .option("--timezone <tz>", "IANA timezone the cron schedule runs in, e.g. America/New_York. Defaults to UTC.")
+        .option("--max-rows <n>", "Per-cycle row cap. The real volume brake on provider writes (BYOK writes cost 0 Oxygen credits).")
+        .option("--max-credits <n>", "Managed-credit + external-quota cap per cycle.")
+        .option("--approved", "Confirm a live configuration after inspecting a dry run.")
+        .option("--dry-run", "Preview the configuration and next cycle without writing. Default.")
+        .option("--live", "Write the configuration. Requires --approved and --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm sync configure", options, () => requestOxygen("/api/cli/crm/sync/configure", {
+            method: "POST",
+            body: buildCrmSyncConfigureBody(options),
+        }));
+    }))
+        .addCommand(new Command("run")
+        .description("Run one bidirectional reconciliation cycle for a configured CRM object pair as a durable workflow run. Defaults to dry-run.")
+        .requiredOption("--provider <provider>", "Connected CRM: hubspot or attio.")
+        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, or attio people|companies.")
+        .option("--max-rows <n>", "Per-cycle row cap. The real volume brake on provider writes (BYOK writes cost 0 Oxygen credits).")
+        .option("--max-credits <n>", "Managed-credit + external-quota cap for this cycle.")
+        .option("--approved", "Confirm a live cycle after inspecting a dry run.")
+        .option("--dry-run", "Preview the cycle without pulling or pushing. Default.")
+        .option("--live", "Run the live reconciliation cycle. Requires --approved and --max-credits.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm sync run", options, () => requestOxygen("/api/cli/crm/sync/run", {
+            method: "POST",
+            body: buildCrmSyncRunBody(options),
+        }));
+    }))
+        .addCommand(new Command("enable")
+        .description("Enable continuous (scheduled) bidirectional sync for one CRM object pair: arms the cron trigger + the standing write permission, and runs an immediate first cycle. Always live — requires --approved, --max-credits, and --max-rows.")
+        .requiredOption("--provider <provider>", "Connected CRM: hubspot or attio.")
+        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, or attio people|companies.")
+        .option("--direction <direction>", "Sync direction: inbound, outbound, or bidirectional. Defaults to bidirectional.")
+        .option("--cron <cron>", "Cron expression for the cadence, e.g. '*/15 * * * *'. Defaults to every 15 minutes.")
+        .option("--timezone <tz>", "IANA timezone the cron runs in. Defaults to UTC.")
+        .requiredOption("--max-rows <n>", "Per-cycle row cap — the volume brake on provider writes (required).")
+        .requiredOption("--max-credits <n>", "Managed-credit + external-quota cap per cycle (required).")
+        .option("--approved", "Confirm enabling scheduled provider writes after inspecting a dry run.")
+        .option("--no-run-now", "Do not run an immediate first cycle after enabling.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm sync enable", options, () => requestOxygen("/api/cli/crm/sync/enable", {
+            method: "POST",
+            body: buildCrmSyncEnableBody(options),
+        }));
+    }))
+        .addCommand(new Command("disable")
+        .description("Disable the scheduled sync for one CRM object pair: stops the cron trigger and revokes the standing write permission. The standing config (direction, cadence, mappings, watermarks) is preserved for re-enable.")
+        .requiredOption("--provider <provider>", "Connected CRM: hubspot or attio.")
+        .requiredOption("--object <object>", "Provider object: hubspot contacts|companies, or attio people|companies.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm sync disable", options, () => requestOxygen("/api/cli/crm/sync/disable", {
+            method: "POST",
+            body: buildCrmSyncDisableBody(options),
+        }));
     }))
         .addCommand(new Command("status")
-        .description("Show the status of a CRM import workflow run.")
-        .argument("<run_id>", "Import workflow run id.")
+        .description("Show a CRM sync status: pass --run-id for one workflow run, or --provider/--object for the standing sync config (cadence, watermarks, last-cycle counts).")
+        .argument("[run_id]", "Workflow run id. Equivalent to --run-id.")
+        .option("--run-id <id>", "Workflow run id to read a single run.")
+        .option("--provider <provider>", "Connected CRM (hubspot|attio) for a standing-config read. Use with --object.")
+        .option("--object <object>", "Provider object for a standing-config read. Use with --provider.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("crm sync status", options, () => requestOxygen(buildCrmSyncStatusPath(runId)));
+        const resolved = {
+            ...options,
+            ...(runId !== undefined && readOption(options.runId) === null ? { runId } : {}),
+        };
+        await handleAsyncAction("crm sync status", resolved, () => requestOxygen(buildCrmSyncConfigStatusPath(resolved)));
     }))
         .addCommand(new Command("links")
         .description("Show provider record links (HubSpot/Attio ids) mapped to one Oxygen CRM record.")
@@ -1908,6 +2131,15 @@ export function createProgram() {
                 ...(options.includeArchived ? { include_archived: true } : {}),
             },
         }));
+    }))
+        .addCommand(new Command("tidy-suggest")
+        .description("Read-only tidy analysis for a workspace table: duplicate columns, formatting issues, hide candidates, and value-sanity findings.")
+        .argument("<table>", "Table id or slug.")
+        .option("--limit <n>", "Maximum rows to sample for the analysis. Defaults to and is capped at 5000.")
+        .option("--categories <csv>", "Comma-separated subset of duplicates,formatting,hide,valueSanity. Defaults to all four.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleTablesTidySuggestAction(table, options);
     }))
         .addCommand(new Command("activity")
         .description("Show background runs active on a workspace table right now, with a worker-queue health rollup.")
@@ -2193,6 +2425,21 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("context assets list", options, () => requestOxygen(`/api/cli/context/assets${contextAssetsQuery(options)}`));
+    }))
+        .addCommand(new Command("search")
+        .description("Full-text 'second brain' search across context assets, ranked by relevance.")
+        .requiredOption("--query <text>", "Search text. Supports quoted phrases, OR, and -exclude.")
+        .option("--type <type>", "Filter by playbook, strategy, campaign, positioning, brand, voice, persona, competitor, research_note, message_playbook, or other.")
+        .option("--status <status>", "Filter by draft, active, or archived.")
+        .option("--tags <csv>", "Comma-separated tags that must be present.")
+        .option("--include-archived", "Include archived assets when no status filter is set.")
+        .option("--limit <n>", "Maximum assets to return. Defaults to 100; hard cap is 500.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("context assets search", options, () => requestOxygen("/api/cli/context/assets/search", {
+            method: "POST",
+            body: buildContextAssetSearchBody(options),
+        }));
     }))
         .addCommand(new Command("get")
         .description("Read one context asset.")
@@ -2816,6 +3063,29 @@ export function createProgram() {
             method: "POST",
             body: { table, column },
         }));
+    }))
+        .addCommand(new Command("reorder")
+        .description("Move a workspace column to a new position, by absolute index or relative to another column.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<column>", "Column id or key to move.")
+        .option("--position <n>", "Target zero-based index for the column.")
+        .option("--before <column>", "Place the column immediately before this column id or key.")
+        .option("--after <column>", "Place the column immediately after this column id or key.")
+        .option("--dry-run", "Return the would-be position without persisting the reorder.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, column, options) => {
+        await handleAsyncAction("columns reorder", options, async () => {
+            const position = await resolveColumnReorderPosition(table, column, options);
+            return requestOxygen("/api/cli/tables/columns/reorder", {
+                method: "POST",
+                body: {
+                    table,
+                    column,
+                    position,
+                    ...(options.dryRun ? { dry_run: true } : {}),
+                },
+            });
+        });
     }));
     program
         .command("action-column")
@@ -4430,6 +4700,7 @@ export function createProgram() {
         .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("--sales-nav", "Request Classic + Sales Navigator access during Unipile hosted authentication.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("senders connect", options, () => {
@@ -4438,6 +4709,7 @@ export function createProgram() {
                 method: "POST",
                 body: {
                     ...(reconnect ? { reconnect_connection_id: reconnect } : {}),
+                    ...(options.salesNav ? { sales_nav: true } : {}),
                 },
             });
         });
@@ -4448,6 +4720,13 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("senders get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}`));
+    }))
+        .addCommand(new Command("health")
+        .description("Show a one-call health snapshot for a LinkedIn sender: status, the latest error reason, any open security checkpoint, today's usage, the warm-up ramp, and when the daily quota resets. Read-only — no provider call, no credits. <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("senders health", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/health`));
     }))
         .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.")
@@ -4473,6 +4752,29 @@ export function createProgram() {
             method: "POST",
         }));
     }))
+        .addCommand(new Command("checkpoint")
+        .description("Resolve a LinkedIn security checkpoint (2FA / OTP / in-app validation) so a stuck sender can return to active. Account administration — no credits, no approval gate.")
+        .option("--json", "Print a JSON envelope.")
+        .addCommand(new Command("solve")
+        .description("Submit the LinkedIn checkpoint code Unipile is waiting on to finish authentication. <id> accepts a sender account id, connection id, or Unipile account id; <code> is the verification code LinkedIn sent.")
+        .argument("<id>", "Sender account id, connection id, or Unipile account id.")
+        .argument("<code>", "The verification code LinkedIn sent (2FA / OTP / in-app validation).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, code, options) => {
+        await handleAsyncAction("senders checkpoint solve", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/checkpoint/solve`, {
+            method: "POST",
+            body: { code },
+        }));
+    }))
+        .addCommand(new Command("resend")
+        .description("Ask LinkedIn to resend the checkpoint code so you can read a fresh one, then submit it with `senders checkpoint solve`. <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("senders checkpoint resend", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/checkpoint/resend`, {
+            method: "POST",
+        }));
+    })))
         .addCommand(new Command("limits")
         .description("View and adjust per-account daily action limits and the daily-reset timezone.")
         .option("--json", "Print a JSON envelope.")
@@ -4497,8 +4799,9 @@ export function createProgram() {
         .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("--sales-nav-search-results-per-day <n>", "Daily cap on Sales Navigator search result rows fetched.")
         .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("--total-reads-per-day <n>", "Daily cap across all read units.")
         .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 the daily action counters reset in, e.g. America/New_York.")
@@ -4549,6 +4852,80 @@ export function createProgram() {
             return requestOxygen(`/api/cli/linkedin/connections/status${suffix ? `?${suffix}` : ""}`);
         });
     })));
+    program.addCommand(new Command("followers")
+        .description("Read a LinkedIn account's followers into a Clay-like workspace table and an enrollable CRM list you can enrich, qualify, and enroll from. Imports run as a slow, durable background drip under a dedicated conservative read budget — they never burst and never starve the sequencer's own reads.")
+        .addCommand(new Command("import")
+        .description("Start (or re-arm) a followers import. Followers drip into a workspace table + the deduped mirror over many ticks, and newly-seen people are bridged into an enrollable CRM static list; poll `followers status` to watch them accrue. The import keeps itself fresh by periodically re-walking followers in the background (new followers dedupe in). No messages are sent and no Oxygen credits are charged.")
+        .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id). Omit to import every active LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to import into. Omit to create or reuse a 'LinkedIn Followers' table.")
+        .option("--list <slug>", "Enrollable CRM static list slug to bridge new followers into. Omit for the default 'linkedin-followers' list.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("followers import", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            const list = readOption(options.list);
+            return requestOxygen("/api/cli/linkedin/followers/import", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                    ...(list ? { list } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show followers-import progress (per-sender drip status, followers ingested, last error) plus a preview of the followers table, the enrollable CRM list, and a deep-link to open it.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("followers status", options, () => {
+            const account = readOption(options.account);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/followers/status${suffix ? `?${suffix}` : ""}`);
+        });
+    })));
+    program.addCommand(new Command("viewers")
+        .description("Read the named LinkedIn 'who viewed my profile' (WVMP) viewers into a Clay-like workspace table and an enrollable CRM list. Imports run as a slow, durable background drip under a dedicated conservative read budget. LinkedIn hides anonymous/private viewers, so the list is always a partial sample.")
+        .addCommand(new Command("import")
+        .description("Start (or re-arm) a durable profile-viewers (WVMP) import. Named viewers drip into a workspace table + the deduped mirror (view_count / last_viewed_at accumulate) over many ticks, and newly-seen viewers are bridged into an enrollable CRM static list; poll `viewers status` to watch them accrue. No messages are sent and no Oxygen credits are charged.")
+        .option("--account <ref>", "Sender account to import (sender id, connection id, or Unipile account id). Omit to import every active LinkedIn account.")
+        .option("--table <ref>", "Existing workspace table (id or slug) to import into. Omit to create or reuse a 'LinkedIn Profile Viewers' table.")
+        .option("--list <slug>", "Enrollable CRM static list slug to bridge new viewers into. Omit for the default 'linkedin-profile-viewers' list.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("viewers import", options, () => {
+            const account = readOption(options.account);
+            const table = readOption(options.table);
+            const list = readOption(options.list);
+            return requestOxygen("/api/cli/linkedin/viewers/import", {
+                method: "POST",
+                body: {
+                    ...(account ? { account } : {}),
+                    ...(table ? { table } : {}),
+                    ...(list ? { list } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("status")
+        .description("Show durable profile-viewers (WVMP) import progress (per-sender drip status, viewers ingested, last error, the preserved privacy ceiling note) plus a preview of the viewers table, the enrollable CRM list, and a deep-link to open it.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("viewers status", options, () => {
+            const account = readOption(options.account);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/viewers/status${suffix ? `?${suffix}` : ""}`);
+        });
+    })));
     program.addCommand(new Command("engagement")
         .description("Harvest a LinkedIn post's engagers (reactors + commenters) into an enrollable CRM static list. The harvest runs as a slow, durable background drip under a dedicated conservative read budget — it never bursts and never starves the sequencer's own reads.")
         .addCommand(new Command("harvest")
@@ -4605,6 +4982,67 @@ export function createProgram() {
             const suffix = params.toString();
             return requestOxygen(`/api/cli/linkedin/engagement/harvest${suffix ? `?${suffix}` : ""}`);
         });
+    }))
+        .addCommand(new Command("react")
+        .description("React to a LinkedIn post (or to a comment with --comment-id). A real external LinkedIn write that everyone can see and that counts against the sender account's daily action quota, gated behind approval: prints a preview by default and only reacts when you pass --approved. --post is the composite post social_id from `oxygen posts get` (NOT the activity URN).")
+        .requiredOption("--post <social_id>", "Composite post social_id from `oxygen posts get` (NOT the activity URN).")
+        .option("--reaction-type <type>", "Reaction kind: like, celebrate, support, love, insightful, or funny (default like).")
+        .option("--comment-id <id>", "React to this comment id instead of the post itself.")
+        .option("--as-organization <org>", "LinkedIn organization id to react as a company page.")
+        .option("--account <ref>", "Sender account that reacts (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--approved", "Actually add the reaction. Omit to preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("engagement react", options, () => {
+            const post = readOption(options.post);
+            const reactionType = readOption(options.reactionType);
+            const commentId = readOption(options.commentId);
+            const asOrganization = readOption(options.asOrganization);
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/engagement/react", {
+                method: "POST",
+                body: {
+                    ...(post ? { post } : {}),
+                    ...(reactionType ? { reaction_type: reactionType } : {}),
+                    ...(commentId ? { comment_id: commentId } : {}),
+                    ...(asOrganization ? { as_organization: asOrganization } : {}),
+                    ...(account ? { account } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("comment")
+        .description("Comment on a LinkedIn post (or reply to a comment with --comment-id). A real external LinkedIn write that everyone can see and that counts against the sender account's daily action quota, gated behind approval: prints a preview by default and only posts when you pass --approved. --post is the composite post social_id from `oxygen posts get` (NOT the activity URN).")
+        .requiredOption("--post <social_id>", "Composite post social_id from `oxygen posts get` (NOT the activity URN).")
+        .requiredOption("--text <text>", "Comment text to post.")
+        .option("--comment-id <id>", "Reply under this comment id instead of commenting on the post.")
+        .option("--as-organization <org>", "LinkedIn organization id to comment as a company page.")
+        .option("--external-link <url>", "URL to attach as a link preview on the comment.")
+        .option("--account <ref>", "Sender account that comments (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--approved", "Actually post the comment. Omit to preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("engagement comment", options, () => {
+            const post = readOption(options.post);
+            const text = readOption(options.text);
+            const commentId = readOption(options.commentId);
+            const asOrganization = readOption(options.asOrganization);
+            const externalLink = readOption(options.externalLink);
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/engagement/comment", {
+                method: "POST",
+                body: {
+                    ...(post ? { post } : {}),
+                    ...(text ? { text } : {}),
+                    ...(commentId ? { comment_id: commentId } : {}),
+                    ...(asOrganization ? { as_organization: asOrganization } : {}),
+                    ...(externalLink ? { external_link: externalLink } : {}),
+                    ...(account ? { account } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
     })));
     program.addCommand(new Command("linkedin")
         .description("LinkedIn read-into-workspace ingestion controls (Goal-3): the unified status of the connections / engagement / message-history drips and each account's remaining ingest read budget.")
@@ -4623,6 +5061,74 @@ export function createProgram() {
             const suffix = params.toString();
             return requestOxygen(`/api/cli/linkedin/ingestion/status${suffix ? `?${suffix}` : ""}`);
         });
+    })))
+        .addCommand(new Command("connections")
+        .description("Send LinkedIn connection invitations from a sender account.")
+        .addCommand(new Command("invite")
+        .description("Send a LinkedIn connection invitation. A real external social action gated behind approval: prints a preview by default and only sends when you pass --approved. The recipient can be a member provider id (ACo…) or a profile URL / public identifier. The per-account invite quota and warm-up ramp are enforced server-side, and already-invited recipients are de-duplicated automatically.")
+        .requiredOption("--recipient <id_or_url>", "Recipient LinkedIn provider id (ACo…) or profile URL / public identifier.")
+        .option("--account <ref>", "Sender account that sends the invite (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--message <text>", "Optional invitation note (~300 chars max).")
+        .option("--approved", "Actually send the invite. Omit to preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin connections invite", options, () => {
+            const recipient = readOption(options.recipient);
+            const account = readOption(options.account);
+            const message = readOption(options.message);
+            return requestOxygen("/api/cli/linkedin/connections/invite", {
+                method: "POST",
+                body: {
+                    ...(recipient ? { recipient } : {}),
+                    ...(account ? { account } : {}),
+                    ...(message ? { message } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    })))
+        .addCommand(new Command("invitations")
+        .description("List and withdraw the pending LinkedIn connection invitations a sender account has sent.")
+        .addCommand(new Command("withdraw")
+        .description("Withdraw pending sent LinkedIn invitations. A real external social action gated behind approval: prints the resolved target list by default and only withdraws when you pass --approved. Select targets with --ids (a comma-separated id list from `linkedin invitations list`) OR --older-than <days> (pending invites older than N days, among the 100 most recent sent) — not both. Idempotent: an invite that is already gone counts as withdrawn.")
+        .option("--ids <a,b>", "Comma-separated invitation ids to withdraw (from `linkedin invitations list`).")
+        .option("--older-than <days>", "Withdraw pending sent invites older than this many days (among the 100 most recent sent) instead of an explicit id list.")
+        .option("--account <ref>", "Sender account (sender id, connection id, or Unipile account id). Omit for the org default.")
+        .option("--approved", "Actually withdraw. Omit to preview the target list only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations withdraw", options, () => {
+            const ids = (options.ids ?? "").split(",").map((id) => id.trim()).filter(Boolean);
+            const olderThan = readPositiveInteger(options.olderThan);
+            const account = readOption(options.account);
+            return requestOxygen("/api/cli/linkedin/connections/invite/withdraw", {
+                method: "POST",
+                body: {
+                    ...(ids.length > 0 ? { invitation_ids: ids } : {}),
+                    ...(olderThan !== undefined ? { older_than_days: olderThan } : {}),
+                    ...(account ? { account } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("list")
+        .description("List the account's pending sent LinkedIn invitations with their invitation ids — the ids `linkedin invitations withdraw --ids` cancels. Read-only: no provider write, no credits.")
+        .option("--account <ref>", "Scope to one sender account (sender id, connection id, or Unipile account id).")
+        .option("--limit <n>", "Maximum invitations to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("linkedin invitations list", options, () => {
+            const account = readOption(options.account);
+            const limit = readPositiveInteger(options.limit);
+            const params = new URLSearchParams();
+            if (account)
+                params.set("account", account);
+            if (limit !== undefined)
+                params.set("limit", String(limit));
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/linkedin/connections/invites-sent${suffix ? `?${suffix}` : ""}`);
+        });
     }))));
     program.addCommand(new Command("whatsapp")
         .description("Manage the org's connected WhatsApp accounts for Sequencer: list, connect, sync, inspect, disconnect, tune daily limits, and warm-send into an existing conversation. Cold outbound runs through a WhatsApp sequence (sequences create --channels whatsapp).")
@@ -4866,13 +5372,14 @@ export function createProgram() {
         .description("Run analysis on a conversation now: status + sentiment + a drafted reply (Oxygen's default model). The worker also does this automatically on inbound conversations.")
         .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
         .option("--channel <channel>", "Inbox channel: email (default), linkedin, or whatsapp.")
+        .option("--force", "Re-analyze even if the conversation was already classified (an explicit paid re-classification; spends one managed credit). Without it, an already-analyzed email is a free no-op. DMs always re-analyze.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
         await handleAsyncAction("inbox analyze", options, () => {
             const channel = readOption(options.channel) ?? "email";
             return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/analyze`, {
                 method: "POST",
-                body: { channel },
+                body: { channel, ...(options.force ? { force: true } : {}) },
             });
         });
     }))
@@ -5367,9 +5874,11 @@ export function createProgram() {
         await handleAsyncAction("sequences get", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}`));
     }))
         .addCommand(new Command("enroll")
-        .description("Enroll leads into a sequence from a JSON file of { leads: [...] }. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row.")
+        .description("Enroll leads into a sequence from a JSON file of { leads: [...] }. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row. The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason).")
         .argument("<sequence>", "Sequence id or slug.")
         .requiredOption("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ lead_provider_id, lead_name, table_row_id, row_values }] }.")
+        .option("--exclude-contacted", "Also skip leads any OTHER active sequence is already contacting (cross-campaign exclusion). Off by default.")
+        .option("--suppress-list <ids>", "Per-call do-not-enroll lead provider ids dropped for this enroll only: a comma-separated list, or @<path> to a file of ids (comma/whitespace separated).")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
         await handleAsyncAction("sequences enroll", options, () => {
@@ -5377,9 +5886,14 @@ export function createProgram() {
             if (!leadsPath)
                 throw new Error("--leads-file is required.");
             const parsed = readJsonFileValue(resolve(leadsPath), "--leads-file");
+            const suppressList = parseSuppressListOption(options.suppressList);
             return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enroll`, {
                 method: "POST",
-                body: { leads: parsed.leads ?? [] },
+                body: {
+                    leads: parsed.leads ?? [],
+                    ...(options.excludeContacted ? { exclude_contacted: true } : {}),
+                    ...(suppressList.length > 0 ? { suppress_list: suppressList } : {}),
+                },
             });
         });
     }))
@@ -5476,6 +5990,71 @@ export function createProgram() {
         .action(async (sequence, options) => {
         await handleSequenceVariantsAction(sequence, options);
     })));
+    program.addCommand(new Command("suppressions")
+        .description("Org do-not-contact list (people/multichannel): lead provider ids the sequencer enroller always skips at plan time. list | add | remove. Consumes 0 credits.")
+        .addCommand(new Command("list")
+        .description("List the org's do-not-contact suppressions, newest first. Filter by --reason or by --search (case-insensitive substring of the lead provider id).")
+        .option("--reason <reason>", "Filter by reason: manual, replied, unsubscribed, bounced, do_not_contact, friends.")
+        .option("--search <text>", "Case-insensitive substring match on the lead provider id.")
+        .option("--limit <n>", "Maximum suppressions to return (1-500; default 100).")
+        .option("--offset <n>", "Pagination offset (0-based).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions list", options, () => {
+            const params = new URLSearchParams();
+            const reason = readOption(options.reason);
+            if (reason)
+                params.set("reason", reason);
+            const search = readOption(options.search);
+            if (search)
+                params.set("search", search);
+            const limit = readOption(options.limit);
+            if (limit)
+                params.set("limit", limit);
+            const offset = readOption(options.offset);
+            if (offset)
+                params.set("offset", offset);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/suppressions${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("add")
+        .description("Add (or refresh) a lead provider id on the org do-not-contact list so the sequencer never enrolls them again. Idempotent. --reason defaults to manual.")
+        .requiredOption("--lead <provider_id>", "The lead provider id (e.g. a LinkedIn ACo... id) to suppress.")
+        .option("--reason <reason>", "Why: manual (default), replied, unsubscribed, bounced, do_not_contact, friends.")
+        .option("--detail <text>", "Optional free-text note stored with the suppression.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions add", options, () => {
+            const lead = readOption(options.lead);
+            if (!lead)
+                throw new Error("--lead is required.");
+            const reason = readOption(options.reason);
+            const detail = readOption(options.detail);
+            return requestOxygen("/api/cli/suppressions", {
+                method: "POST",
+                body: {
+                    lead_provider_id: lead,
+                    ...(reason ? { reason } : {}),
+                    ...(detail ? { detail } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("remove")
+        .description("Remove a lead provider id from the org do-not-contact list (re-enable contact).")
+        .requiredOption("--lead <provider_id>", "The lead provider id to un-suppress.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions remove", options, () => {
+            const lead = readOption(options.lead);
+            if (!lead)
+                throw new Error("--lead is required.");
+            return requestOxygen(`/api/cli/suppressions?lead_provider_id=${encodeURIComponent(lead)}`, {
+                method: "DELETE",
+            });
+        });
+    })));
     program.addCommand(new Command("email")
         .description("Ad-hoc email from the org's sending fleet: one-off sends with no sequence, enrollment, or contact sync. Zapbox-connected mailboxes send through Zapmail's API (no Google/Microsoft consent); BYOK — 0 Oxygen credits.")
         .addCommand(new Command("send")
@@ -5520,6 +6099,13 @@ export function createProgram() {
             const suffix = params.toString();
             return requestOxygen(`/api/cli/mailboxes${suffix ? `?${suffix}` : ""}`);
         });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one sending mailbox's detail (provider, status, daily cap, warmup state, auth mode) plus a one-row pool summary. <mailbox> accepts a mailbox id or email address.")
+        .argument("<mailbox>", "Mailbox id or email address.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (mailbox, options) => {
+        await handleAsyncAction("mailboxes get", options, () => requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}`));
     }))
         .addCommand(new Command("import")
         .description("Register (or refresh) sending mailboxes in bulk. Provide --file (a JSON file: { \"mailboxes\": [{ email_address, provider, workspace_external_id? }] }) or --from zapmail to pull the connected Zapmail workspace's mailbox list. Upsert is keyed by address, so re-importing never duplicates a mailbox.")
@@ -5571,6 +6157,24 @@ export function createProgram() {
             });
         });
     }))
+        .addCommand(new Command("cap")
+        .description("View and adjust a single mailbox's daily send cap (throttle a problem inbox or ramp a newly warmed one without pausing it).")
+        .addCommand(new Command("set")
+        .description("Set one sending mailbox's daily send cap (sends per day). --daily-cap must be a positive whole number. Consumes no Oxygen credits. <mailbox> accepts a mailbox id or email address.")
+        .argument("<mailbox>", "Mailbox id or email address.")
+        .requiredOption("--daily-cap <n>", "New daily send cap (a positive whole number of sends per day).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (mailbox, options) => {
+        await handleAsyncAction("mailboxes cap set", options, () => {
+            const raw = readOption(options.dailyCap);
+            if (!raw)
+                throw new Error("--daily-cap is required.");
+            return requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}/cap`, {
+                method: "PATCH",
+                body: { daily_cap: Number(raw) },
+            });
+        });
+    })))
         .addCommand(new Command("connect-oauth")
         .description("Provision Zapmail Custom OAuth across the mailbox pool: registers Oxygen's own OAuth app with Zapmail, which authorizes it across the Workspaces so native send needs no per-Workspace delegation. BYOK — Zapmail bills your account, 0 Oxygen credits. Pass --status <export_id> to poll a run.")
         .option("--provider <provider>", "Mailbox provider to provision: google or microsoft.")
@@ -5847,6 +6451,16 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("workflows schema", options, () => requestOxygen(`/api/cli/workflows/schema?subject=${encodeURIComponent(options.subject ?? "all")}`));
+    }))
+        .addCommand(new Command("init")
+        .description("Scaffold a local durable-recipe project (starter recipe, vendored @oxygen/recipe-sdk types, tsconfig) so your editor resolves the SDK without an npm install.")
+        .option("--dir <path>", "Directory to scaffold into. Defaults to the current directory.")
+        .option("--id <id>", "Recipe id for the starter file. Defaults to 'my-recipe'.")
+        .option("--name <name>", "Recipe display name. Defaults to 'My recipe'.")
+        .option("--force", "Overwrite existing files instead of skipping them.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("workflows init", options, async () => scaffoldRecipeProject(options));
     }))
         .addCommand(new Command("lint")
         .description("Compile and lint a workflow file without saving it.")
@@ -6166,6 +6780,131 @@ function asWorkflowCompileError(error, filePath) {
         exitCode: 1,
     });
 }
+// ---- oxygen workflows init: scaffold a local durable-recipe project ----
+//
+// @oxygen/recipe-sdk is never published to npm — it ships bundled inside this CLI
+// (scripts/build-cli-npm-package.mjs → bundledDependencies). `init` vendors the SDK's
+// compiled type declarations into the user's project so their editor resolves
+// `@oxygen/recipe-sdk` (and the `@oxygen/workflows` types it re-exports) without an npm
+// install. We read the .d.ts from the same node paths esbuild uses to bundle the runtime
+// at `apply` time, so the vendored types stay locked to the CLI actually installed.
+const RECIPE_TYPES_VENDOR_DIR = ".oxygen/types";
+const RECIPE_INIT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/i;
+function readBundledSdkDts(pkg) {
+    for (const base of RECIPE_ESBUILD_NODE_PATHS) {
+        const candidate = join(base, "@oxygen", pkg, "dist", "index.d.ts");
+        if (existsSync(candidate)) {
+            try {
+                return readFileSync(candidate, "utf8");
+            }
+            catch {
+                // Unreadable copy — fall through to the next node path.
+            }
+        }
+    }
+    return null;
+}
+function renderStarterRecipe(id, name) {
+    return [
+        `import { defineRecipe, type RecipeContext } from "@oxygen/recipe-sdk";`,
+        ``,
+        `// A durable recipe is the default export of defineRecipe(...); it compiles into an`,
+        `// Oxygen workflow. Recipes reach external systems ONLY through catalog tools —`,
+        `// raw fetch/network is disabled in the recipe sandbox.`,
+        `//`,
+        `// Deploy:  oxygen workflows apply --file ./${id}.ts`,
+        `// Dry-run: oxygen workflows call <workflow-id> --mode dry_run --json`,
+        `// Docs:    https://oxygen-agent.com/docs/authoring/recipes`,
+        `export default defineRecipe({`,
+        `  id: ${JSON.stringify(id)},`,
+        `  name: ${JSON.stringify(name)},`,
+        `  // Allowlist of every tool id this recipe may call — including native table`,
+        `  // ops, which dispatch through oxygen.* tools (e.g. oxygen.rows_upsert for`,
+        `  // ctx.rows.upsert). Discover provider tools with: oxygen tools search <query>`,
+        `  tools: ["firecrawl.scrape", "oxygen.rows_upsert"],`,
+        `  trigger: { type: "api" },`,
+        `  inputSchema: {`,
+        `    type: "object",`,
+        `    properties: {},`,
+        `  },`,
+        `  async run(ctx: RecipeContext) {`,
+        `    ctx.log("info", "recipe started", { mode: ctx.mode });`,
+        `    // Example: pull data through a tool, then persist it to a table.`,
+        `    //   const page = await ctx.tools.run("firecrawl.scrape", { url }, { key: "scrape" });`,
+        `    //   await ctx.rows.upsert("my_table", rows, { key: "save", upsertKey: "id" });`,
+        `    return { ok: true, at: await ctx.now() };`,
+        `  },`,
+        `});`,
+        ``,
+    ].join("\n");
+}
+function renderRecipeTsconfig() {
+    const tsconfig = {
+        compilerOptions: {
+            target: "ES2022",
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            strict: true,
+            noEmit: true,
+            skipLibCheck: true,
+            types: [],
+            // paths are resolved relative to this tsconfig (moduleResolution "Bundler"
+            // needs no baseUrl — and baseUrl is deprecated in TypeScript 6+).
+            paths: {
+                "@oxygen/recipe-sdk": [`./${RECIPE_TYPES_VENDOR_DIR}/@oxygen/recipe-sdk/index.d.ts`],
+                "@oxygen/workflows": [`./${RECIPE_TYPES_VENDOR_DIR}/@oxygen/workflows/index.d.ts`],
+            },
+        },
+        include: ["*.ts"],
+    };
+    return `${JSON.stringify(tsconfig, null, 2)}\n`;
+}
+function scaffoldRecipeProject(options) {
+    const recipeId = readOption(options.id) ?? "my-recipe";
+    if (!RECIPE_INIT_ID_PATTERN.test(recipeId)) {
+        throw new OxygenError("invalid_recipe_id", "Recipe id must start with a letter or digit and contain only letters, digits, dashes, or underscores.", {
+            details: { id: recipeId },
+            exitCode: 1,
+        });
+    }
+    const recipeName = readOption(options.name) ?? "My recipe";
+    const directory = resolve(readOption(options.dir) ?? ".");
+    const force = options.force === true;
+    const recipeDts = readBundledSdkDts("recipe-sdk");
+    const workflowsDts = readBundledSdkDts("workflows");
+    if (!recipeDts || !workflowsDts) {
+        throw new OxygenError("recipe_sdk_types_unavailable", "Could not locate the @oxygen/recipe-sdk types bundled with this CLI. Update the CLI (npm install -g @oxygen-agent/cli@latest) and retry.", { exitCode: 1 });
+    }
+    const recipeFileName = `${recipeId}.ts`;
+    const targets = [
+        { path: join(directory, recipeFileName), content: renderStarterRecipe(recipeId, recipeName) },
+        { path: join(directory, "tsconfig.json"), content: renderRecipeTsconfig() },
+        { path: join(directory, RECIPE_TYPES_VENDOR_DIR, "@oxygen", "recipe-sdk", "index.d.ts"), content: recipeDts },
+        { path: join(directory, RECIPE_TYPES_VENDOR_DIR, "@oxygen", "workflows", "index.d.ts"), content: workflowsDts },
+    ];
+    const filesWritten = [];
+    const filesSkipped = [];
+    for (const target of targets) {
+        if (existsSync(target.path) && !force) {
+            filesSkipped.push(target.path);
+            continue;
+        }
+        mkdirSync(dirname(target.path), { recursive: true });
+        writeFileSync(target.path, target.content, "utf8");
+        filesWritten.push(target.path);
+    }
+    return {
+        directory,
+        recipe_file: join(directory, recipeFileName),
+        files_written: filesWritten,
+        files_skipped: filesSkipped,
+        next_steps: [
+            `Edit ${recipeFileName}, then find tools with: oxygen tools search <query>`,
+            `Deploy it:  oxygen workflows apply --file ./${recipeFileName}`,
+            `Dry-run it: oxygen workflows call <workflow-id> --mode dry_run --json`,
+        ],
+    };
+}
 async function compileWorkflowFile(filePath) {
     try {
         return await loadWorkflowManifestFromFile(filePath);
@@ -9629,6 +10368,129 @@ function formatSequenceVariants(data) {
     lines.push("");
     return lines.join("\n");
 }
+// `columns reorder` accepts either an absolute --position or a relative
+// --before/--after naming a sibling column. The relative form is resolved
+// client-side into an absolute index against the table's current column order
+// (fetched via /api/cli/tables/describe — the same describe the other column
+// commands read) so the server only ever receives a single numeric position.
+// Exactly one of the three flags must be supplied.
+async function resolveColumnReorderPosition(table, column, options) {
+    const before = readOption(options.before);
+    const after = readOption(options.after);
+    const explicit = readNonNegativeInt(options.position);
+    const provided = [explicit !== undefined, Boolean(before), Boolean(after)].filter(Boolean).length;
+    if (provided === 0) {
+        throw new OxygenError("invalid_request", "Provide --position <n>, --before <column>, or --after <column>.", { exitCode: 1 });
+    }
+    if (provided > 1) {
+        throw new OxygenError("invalid_request", "Pass only one of --position, --before, or --after.", { exitCode: 1 });
+    }
+    if (explicit !== undefined)
+        return explicit;
+    const reference = (before ?? after);
+    const describe = await requestOxygen("/api/cli/tables/describe", { method: "POST", body: { table } });
+    const columns = describe.columns ?? [];
+    const index = columns.findIndex((candidate) => candidate.id === reference || candidate.key === reference);
+    if (index < 0) {
+        throw new OxygenError("invalid_request", `Column "${reference}" was not found on table "${table}".`, { details: { table, column: reference }, exitCode: 1 });
+    }
+    // --before lands the column at the reference's index; --after lands it one slot later.
+    const target = before ? index : index + 1;
+    // The server removes the source column before splicing it back in at `target`.
+    // When the source currently sits before the reference, that removal shifts the
+    // reference (and everything after it) down one slot, so decrement to compensate.
+    const sourceIndex = columns.findIndex((candidate) => candidate.id === column || candidate.key === column);
+    if (sourceIndex >= 0 && sourceIndex < index) {
+        return target - 1;
+    }
+    return target;
+}
+// `tables tidy-suggest` is a read-only analysis (no credits, no writes): it
+// surfaces duplicate columns, formatting inconsistencies, hide candidates, and
+// value-sanity findings so the caller can pick which reversible cleanup to run
+// next. --json returns the raw report envelope; the default rendering compacts
+// the four sections for a terminal reader and echoes the deep-link.
+async function handleTablesTidySuggestAction(table, options) {
+    try {
+        const limit = readPositiveInt(options.limit);
+        const categories = readCsvOption(options.categories);
+        const data = await requestOxygen("/api/cli/tables/tidy/suggest", {
+            method: "POST",
+            body: {
+                table,
+                ...(limit ? { limit } : {}),
+                ...(categories.length ? { categories } : {}),
+            },
+        });
+        if (options.json) {
+            writeJson(success("tables tidy-suggest", data));
+            return;
+        }
+        process.stdout.write(formatTidySuggestions(data));
+    }
+    catch (error) {
+        const failure = toFailure("tables tidy-suggest", error);
+        writeJson(failure);
+        writeMaxCreditsHint(error);
+        process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
+    }
+}
+function formatTidyCount(value) {
+    return typeof value === "number" && Number.isFinite(value) ? String(value) : "0";
+}
+function formatTidyPercent(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return "—";
+    return `${(value * 100).toFixed(0)}%`;
+}
+// Render one tidy-suggest section (header + count, then either a dim "None" or
+// one formatted line per item) into the shared `lines` buffer. Extracted so the
+// four sections share a single control-flow shape instead of repeating it.
+function pushTidySection(lines, styles, title, items, renderItem) {
+    lines.push("", styles.bold(`${title} (${items.length})`));
+    if (items.length === 0) {
+        lines.push(`  ${styles.dim("None")}`);
+        return;
+    }
+    for (const item of items) {
+        lines.push(renderItem(item));
+    }
+}
+function formatTidySuggestions(data) {
+    const styles = ansi(output.isTTY === true && !process.env.NO_COLOR);
+    const duplicates = Array.isArray(data.duplicateColumns) ? data.duplicateColumns : [];
+    const formatting = Array.isArray(data.formattingIssues) ? data.formattingIssues : [];
+    const hide = Array.isArray(data.hideSuggestions) ? data.hideSuggestions : [];
+    const valueSanity = Array.isArray(data.valueSanity) ? data.valueSanity : [];
+    const lines = [
+        "",
+        `${styles.bold("Table tidy suggestions")} ${styles.dim(`(sampled ${formatTidyCount(data.sampledRows)} of ${formatTidyCount(data.rowCount)} rows)`)}`,
+    ];
+    pushTidySection(lines, styles, "Duplicate columns", duplicates, (dup) => {
+        const loser = dup.loserKey ?? dup.loserColumnId ?? "?";
+        const survivor = dup.survivorKey ?? dup.survivorColumnId ?? "?";
+        return `  ${loser} ${styles.dim("→ duplicate of")} ${survivor} ${styles.dim(`(${formatTidyPercent(dup.similarity)} match, ${dup.recommendation ?? "review"})`)}`;
+    });
+    pushTidySection(lines, styles, "Formatting issues", formatting, (issue) => {
+        const sampleCount = Array.isArray(issue.sampleRowIds) ? issue.sampleRowIds.length : 0;
+        const column = issue.columnKey ?? issue.columnId ?? "?";
+        return `  ${column} ${styles.dim(`— ${issue.issue ?? "issue"}`)}${issue.detail ? `: ${issue.detail}` : ""} ${styles.dim(`(${sampleCount} sample row(s))`)}`;
+    });
+    pushTidySection(lines, styles, "Hide suggestions", hide, (suggestion) => {
+        const column = suggestion.columnKey ?? suggestion.columnId ?? "?";
+        return `  ${column} ${styles.dim(`— ${suggestion.reason ?? "hide"} (${formatTidyPercent(suggestion.fillRate)} filled)`)}`;
+    });
+    pushTidySection(lines, styles, "Value-sanity findings", valueSanity, (finding) => {
+        const column = finding.columnKey ?? finding.columnId ?? "?";
+        return `  ${column} ${styles.dim(`row ${finding.rowId ?? "?"} — ${finding.reason ?? "check value"}`)}`;
+    });
+    const link = data.deepLink ?? data.web_url ?? data.url;
+    if (link) {
+        lines.push("", styles.dim(`View table: ${link}`));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
 function formatWhoami(identity, context) {
     const styles = ansi(output.isTTY === true && !process.env.NO_COLOR);
     const email = identity.user.email ?? identity.user.id;
@@ -9947,6 +10809,18 @@ function contextAssetsQuery(options) {
     const value = query.toString();
     return value ? `?${value}` : "";
 }
+function buildContextAssetSearchBody(options) {
+    const tags = readCsvOption(options.tags);
+    const limit = readPositiveInt(options.limit);
+    return {
+        query: (readOption(options.query) ?? "").trim(),
+        ...(readOption(options.type) ? { type: readOption(options.type) } : {}),
+        ...(readOption(options.status) ? { status: readOption(options.status) } : {}),
+        ...(tags.length > 0 ? { tags } : {}),
+        ...(options.includeArchived ? { include_archived: true } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+    };
+}
 function buildBillingLedgerParams(options) {
     const params = new URLSearchParams();
     const days = readPositiveInt(options.days);
@@ -10083,6 +10957,7 @@ options) {
     setLimit("relations_reads_per_day", options.relationsReadsPerDay);
     setLimit("messages_reads_per_day", options.messagesReadsPerDay);
     setLimit("searches_per_day", options.searchesPerDay);
+    setLimit("sales_nav_search_results_per_day", options.salesNavSearchResultsPerDay);
     setLimit("api_reads_per_day", options.apiReadsPerDay);
     setLimit("total_reads_per_day", options.totalReadsPerDay);
     setLimit("min_action_spacing_seconds", options.minSpacingSeconds);