@oxygen-agent/cli 1.162.10 → 1.177.0

package/dist/index.js

@@ -14,14 +14,51 @@ import { inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey,
 import { assertRecipeBundleSafe, assertWorkflowManifest, buildRecipeManifest, compileWorkflowDefinition, isAnyWorkflowManifest, isRecipeManifest, isWorkflowDefinition, isWorkflowManifest, } from "@oxygen/workflows";
 import { isRecipeDefinition } from "@oxygen/recipe-sdk";
 import { createBrowserLoginSession, openBrowser } from "./browser-login.js";
-import { clearCredentials, defaultApiUrl, listCredentialProfiles, normalizeApiUrl, pickProfileNameForIdentity, pickProfileNameForUserSession, resolveActiveProfile, saveCredentials, switchCredentialProfile, updateActiveOrganizationForProfile, } from "./credentials.js";
+import { clearCredentials, defaultApiUrl, listCredentialProfiles, loadCredentials, normalizeApiUrl, pickProfileNameForIdentity, pickProfileNameForUserSession, resolveActiveProfile, saveCredentials, switchCredentialProfile, updateActiveOrganizationForProfile, } from "./credentials.js";
 import { ensureFreshCliForApiUrl, requestOxygen } from "./http-client.js";
+import { waitForCliRun } from "./run-wait.js";
 import { runLocalCustomHttpColumn } from "./local-custom-http-column.js";
 import { captureCurrentTranscript, collectFeedbackEnvironment, TranscriptCaptureError, } from "./transcript.js";
 import { addSessionOutput, addSessionStatus, getSessionUsage, startSession, updateSessionStep, } from "./session.js";
 import { doctorAgentSkills, installAgentSkills, listAgentSkills, runAutomaticSkillsInstall, } from "./skills.js";
 import { resolveCliBinaryName } from "./runtime.js";
 import { updateCli } from "./update.js";
+function buildFindBody(capability, options) {
+    const body = { capability };
+    const set = (key, value) => {
+        if (value)
+            body[key] = value;
+    };
+    if (capability === "company") {
+        set("domain", options.domain);
+        set("name", options.name);
+        set("linkedin_url", options.linkedinUrl);
+        if (options.fields) {
+            const fields = options.fields.split(",").map((field) => field.trim()).filter(Boolean);
+            if (fields.length > 0)
+                body.fields = fields;
+        }
+    }
+    else {
+        set("linkedin_url", options.linkedinUrl);
+        set("full_name", options.fullName);
+        set("first_name", options.firstName);
+        set("last_name", options.lastName);
+        set("email", options.email);
+        set("company_domain", options.companyDomain);
+        set("company_name", options.companyName);
+        set("company_linkedin_url", options.companyLinkedinUrl);
+    }
+    if (options.mode)
+        body.mode = options.mode;
+    const maxCredits = readPositiveNumber(options.maxCredits);
+    if (maxCredits)
+        body.max_credits = maxCredits;
+    // Phone-only opt-in; the route ignores it for other capabilities.
+    if (options.verify)
+        body.verify = true;
+    return body;
+}
 const BROWSER_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 const OXYGEN_SPINNER_INTERVAL_MS = 90;
 const INITIAL_OXYGEN_PROFILE_ENV = process.env.OXYGEN_PROFILE?.trim() || null;
@@ -54,6 +91,14 @@ const TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS = 600;
 const TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS = 5;
 const WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS = 600;
 const WORKFLOW_TAIL_DEFAULT_INTERVAL_SECONDS = 2;
+// Cloudflare domain sync returns partial pages under the request budget; the
+// CLI auto-continues up to this many follow-up POSTs before handing back a
+// still-partial summary.
+const DOMAINS_SYNC_MAX_CONTINUATIONS = 20;
+// Cloudflare's domain-check endpoint accepts at most 20 domains per call.
+const DOMAINS_CHECK_MAX_DOMAINS = 20;
+const DOMAIN_REGISTRATION_WAIT_TIMEOUT_SECONDS = 600;
+const DOMAIN_REGISTRATION_WAIT_INTERVAL_SECONDS = 10;
 const CLI_MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const RECIPE_ESBUILD_NODE_PATHS = [
     resolve("node_modules"),
@@ -83,22 +128,47 @@ async function handleAsyncAction(command, options, action) {
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
-// Paid multi-row column runs require an explicit --max-credits spend cap; the
-// server rejects them with max_credits_required plus a recommended cap. Surface
-// that as a one-line stderr hint so users don't have to dig the value out of the
-// JSON envelope (stderr keeps --json stdout machine-clean).
+// Paid live runs are refused server-side with typed spend-gate errors
+// (max_credits_required, approval_required, spend_cap_required,
+// spend_cap_too_low). Surface each as a one-line stderr hint with the concrete
+// re-run flags so users don't have to dig values out of the JSON envelope
+// (stderr keeps --json stdout machine-clean).
 function writeMaxCreditsHint(error) {
-    if (!(error instanceof OxygenError) || error.code !== "max_credits_required")
-        return;
-    const recommended = readRecommendedMaxCredits(error.details);
-    if (recommended === null)
+    if (!(error instanceof OxygenError))
         return;
-    process.stderr.write(`hint: re-run with --max-credits ${recommended} to approve the spend cap\n`);
+    switch (error.code) {
+        case "max_credits_required": {
+            const recommended = readDetailsNumber(error.details, "recommended_max_credits");
+            if (recommended === null)
+                return;
+            process.stderr.write(`hint: re-run with --max-credits ${recommended} to approve the spend cap\n`);
+            return;
+        }
+        case "approval_required": {
+            const estimated = readDetailsNumber(error.details, "estimated_credits");
+            process.stderr.write(`hint: inspect the dry run, then re-run with --approved --max-credits <n>${estimated !== null ? ` (estimated ~${estimated} credits)` : ""}\n`);
+            return;
+        }
+        case "spend_cap_required": {
+            const estimated = readDetailsNumber(error.details, "estimated_credits");
+            process.stderr.write(`hint: re-run with --max-credits ${estimated !== null ? estimated : "<n>"} to cap the spend\n`);
+            return;
+        }
+        case "spend_cap_too_low": {
+            const estimated = readDetailsNumber(error.details, "estimated_credits")
+                ?? readDetailsNumber(error.details, "estimated_max_credits");
+            if (estimated === null)
+                return;
+            process.stderr.write(`hint: the estimate is ${estimated} credits; re-run with --max-credits ${estimated} or higher\n`);
+            return;
+        }
+        default:
+    }
 }
-function readRecommendedMaxCredits(details) {
+function readDetailsNumber(details, key) {
     if (!details || typeof details !== "object" || Array.isArray(details))
         return null;
-    const value = details.recommended_max_credits;
+    const value = details[key];
     return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function parseJsonObject(value) {
@@ -137,6 +207,33 @@ function parseJsonArray(value) {
     }
     return parsed;
 }
+/**
+ * Parse a JSON command-input value, mapping `JSON.parse` syntax failures to a
+ * typed `invalid_json` envelope. A raw `JSON.parse` throw is an ordinary `Error`,
+ * which `@oxygen/shared`'s `toFailure` flattens to a machine-hostile
+ * `unexpected_error`; routing through here keeps malformed user JSON actionable.
+ * Shape validation, where a caller needs it, stays with the caller. `inputName`
+ * is the user-facing flag or source label, e.g. "--steps-file".
+ */
+function parseJsonValue(value, inputName) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new OxygenError("invalid_json", `${inputName} must be valid JSON.`, {
+            details: { reason: error instanceof Error ? error.message : "unknown" },
+            exitCode: 1,
+        });
+    }
+}
+/**
+ * Read a local file and parse it as JSON command input, surfacing syntax
+ * failures as a typed `invalid_json` envelope tagged with `inputName`. File-read
+ * errors (missing/unreadable path) propagate unchanged — they are not JSON.
+ */
+function readJsonFileValue(path, inputName) {
+    return parseJsonValue(readFileSync(path, "utf8"), inputName);
+}
 async function readDeleteRowIdsOption(options) {
     const rowIdsJson = readOption(options.rowIdsJson);
     const rowIdsFile = readOption(options.rowIdsFile);
@@ -259,6 +356,54 @@ function resolveComposioRunMode(options) {
     }
     return "dry_run";
 }
+const DEFAULT_CRM_SETUP_OBJECTS = ["companies", "people"];
+function buildCrmSetupBody(options) {
+    return {
+        objects: readCrmSetupObjects(options.objects),
+        mode: resolveCrmSetupMode(options),
+        ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+    };
+}
+function readCrmSetupObjects(value) {
+    const objects = readCsvOption(value);
+    return objects.length > 0 ? [...new Set(objects)] : DEFAULT_CRM_SETUP_OBJECTS;
+}
+function resolveCrmSetupMode(options) {
+    if (options.live === true && options.dryRun === true) {
+        throw new OxygenError("conflicting_flags", "Pass either --live or --dry-run, not both.", { exitCode: 1 });
+    }
+    return options.live === true ? "live" : "dry_run";
+}
+function buildCrmAssertBody(object, options) {
+    return {
+        object,
+        identity: parseCrmIdentityOption(options.identity),
+        values: options.valuesJson ? parseJsonObject(options.valuesJson) : {},
+        mode: resolveCrmSetupMode(options),
+    };
+}
+function buildCrmRelationshipUpsertBody(object, rowId, options) {
+    return {
+        object,
+        row_id: rowId,
+        relationship: options.relationship,
+        target: {
+            ...(readOption(options.targetObject) ? { object: readOption(options.targetObject) } : {}),
+            row_id: options.targetRowId,
+        },
+        mode: resolveCrmSetupMode(options),
+    };
+}
+function parseCrmIdentityOption(value) {
+    const separator = value.indexOf("=");
+    if (separator <= 0 || separator === value.length - 1) {
+        throw new OxygenError("invalid_identity", "--identity must be formatted as key=value, for example domain=acme.com or email=ceo@acme.com.", { exitCode: 1 });
+    }
+    return {
+        key: value.slice(0, separator).trim(),
+        value: value.slice(separator + 1).trim(),
+    };
+}
 function readSpecFileBody(path) {
     const text = readFileSync(resolve(path), "utf8");
     try {
@@ -271,6 +416,88 @@ function readSpecFileBody(path) {
         throw error;
     }
 }
+// Builds the `prompts` command tree (list/get/upsert/archive). The
+// deprecated `templates` alias is the identical tree — same subcommands,
+// options, request bodies, and routes — differing only in the parent command
+// name, its description, and the `handleAsyncAction` operation labels, so both
+// surfaces are generated here to stop them drifting (the alias previously
+// duplicated every subcommand). All subcommands hit the shared
+// /api/cli/templates/* routes.
+function buildPromptTemplatesCommand(surface, description) {
+    return new Command(surface)
+        .description(description)
+        .addCommand(new Command("list")
+        .description("List prompt templates in the workspace.")
+        .option("--kind <kind>", "Filter by ai_column_system, scoring_rubric, or other.")
+        .option("--include-archived", "Include archived templates.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction(`${surface} list`, options, () => {
+            const params = new URLSearchParams();
+            const kind = readOption(options.kind);
+            if (kind)
+                params.set("kind", kind);
+            if (options.includeArchived)
+                params.set("include_archived", "true");
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/templates${qs}`);
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Read one prompt template by id or slug.")
+        .argument("<id_or_slug>", "Template UUID or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (idOrSlug, options) => {
+        await handleAsyncAction(`${surface} get`, options, () => requestOxygen("/api/cli/templates/get", {
+            method: "POST",
+            body: idOrSlug.includes("-") && idOrSlug.length >= 32
+                ? { id: idOrSlug }
+                : { slug: idOrSlug },
+        }));
+    }))
+        .addCommand(new Command("upsert")
+        .description("Create or update a prompt template.")
+        .option("--id <id>", "Existing template UUID to update. Omit to create.")
+        .option("--slug <slug>", "Stable slug (kebab-case).")
+        .option("--name <name>", "Human-readable name.")
+        .option("--description <text>", "Short description.")
+        .option("--kind <kind>", "Template kind: ai_column_system, scoring_rubric, or other.")
+        .option("--body <text>", "Prompt body.")
+        .option("--body-file <path>", "Path to a file containing the prompt body.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction(`${surface} upsert`, options, async () => {
+            const body = {};
+            if (readOption(options.id))
+                body.id = readOption(options.id);
+            if (readOption(options.slug))
+                body.slug = readOption(options.slug);
+            if (readOption(options.name))
+                body.name = readOption(options.name);
+            if (readOption(options.description) !== undefined)
+                body.description = readOption(options.description);
+            if (readOption(options.kind))
+                body.kind = readOption(options.kind);
+            if (readOption(options.body))
+                body.body = readOption(options.body);
+            else {
+                const path = readOption(options.bodyFile);
+                if (path) {
+                    const fs = await import("node:fs/promises");
+                    body.body = await fs.readFile(path, "utf8");
+                }
+            }
+            return requestOxygen("/api/cli/templates/upsert", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive a prompt template. Seeded templates cannot be archived.")
+        .argument("<id>", "Template UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction(`${surface} archive`, options, () => requestOxygen("/api/cli/templates/archive", { method: "POST", body: { id } }));
+    }));
+}
 export function createProgram() {
     const program = new Command();
     const binaryName = resolveCliBinaryName();
@@ -371,8 +598,8 @@ export function createProgram() {
         .option("--package <npm_spec>", "Override the npm package spec.")
         .option("--dry-run", "Print the update command without running it.")
         .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleUpdateAction(options);
+        .action((options) => {
+        handleUpdateAction(options);
     });
     program
         .command("api-keys")
@@ -381,7 +608,7 @@ export function createProgram() {
         .description("List active CLI API keys for the current user and organization.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("api-keys list", options, async () => requestOxygen("/api/cli/api-keys"));
+        await handleAsyncAction("api-keys list", options, () => requestOxygen("/api/cli/api-keys"));
     }))
         .addCommand(new Command("create")
         .description("Create a CLI API key. The token is shown once.")
@@ -390,7 +617,7 @@ export function createProgram() {
         .option("--expires-in-days <days>", "Expire the key after this many days.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("api-keys create", options, async () => requestOxygen("/api/cli/api-keys", {
+        await handleAsyncAction("api-keys create", options, () => requestOxygen("/api/cli/api-keys", {
             method: "POST",
             body: buildApiKeyCreateBody(options),
         }));
@@ -400,7 +627,7 @@ export function createProgram() {
         .argument("<key-id>", "CLI API key id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (keyId, options) => {
-        await handleAsyncAction("api-keys revoke", options, async () => requestOxygen(`/api/cli/api-keys/${encodeURIComponent(keyId)}`, {
+        await handleAsyncAction("api-keys revoke", options, () => requestOxygen(`/api/cli/api-keys/${encodeURIComponent(keyId)}`, {
             method: "DELETE",
         }));
     }));
@@ -429,13 +656,26 @@ export function createProgram() {
     }));
     program
         .command("status")
-        .description("Compare the local Oxygen CLI version against what's deployed in prod.")
+        .description("Compare the local Oxygen CLI version against the active profile's deployed Oxygen API.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("status", options, async () => {
-            const server = await requestOxygen("/api/health", { requireAuth: false, enforceMinimumCliVersion: false });
+            // Resolve the API URL exactly like authenticated commands do: the
+            // active profile (honoring --profile / OXYGEN_PROFILE / OXYGEN_API_URL
+            // overrides), falling back to the default prod URL only when no
+            // credentials are stored. Without this, requestOxygen's
+            // requireAuth:false path skips loadCredentials() and always hits prod,
+            // so `status` reports a different deployment than every other command.
+            const credentials = await loadCredentials();
+            const apiUrl = credentials?.apiUrl ?? defaultApiUrl();
+            const server = await requestOxygen("/api/health", {
+                credentials: credentials ?? { token: "", apiUrl },
+                requireAuth: false,
+                enforceMinimumCliVersion: false,
+            });
             return {
                 client_version: OXYGEN_VERSION,
+                api_url: apiUrl,
                 server_version: server.server_version,
                 minimum_cli_version: server.minimum_cli_version ?? null,
                 sha: server.sha,
@@ -451,7 +691,7 @@ export function createProgram() {
         .description("List organizations available to the current CLI identity.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("orgs list", options, async () => requestOxygen("/api/cli/orgs"));
+        await handleAsyncAction("orgs list", options, () => requestOxygen("/api/cli/orgs"));
     }))
         .addCommand(new Command("use")
         .description("Select the active organization for this CLI profile.")
@@ -604,20 +844,20 @@ export function createProgram() {
         .description("Show the current organization's tenant database status. Staff can pass global --org to inspect another org.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db status", options, async () => requestOxygen("/api/cli/db/status"));
+        await handleAsyncAction("db status", options, () => requestOxygen("/api/cli/db/status"));
     }))
         .addCommand(new Command("provision")
         .description("Provision a managed Neon tenant database for the current organization. Staff can pass global --org to repair another org.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db provision", options, async () => requestOxygen("/api/cli/db/provision", { method: "POST", body: {} }));
+        await handleAsyncAction("db provision", options, () => requestOxygen("/api/cli/db/provision", { method: "POST", body: {} }));
     }))
         .addCommand(new Command("migrate")
         .description("Apply pending tenant database migrations for the current organization.")
         .option("--rotate-credentials", "Rotate the tenant runtime/read DB passwords and rewrite stored credentials. Use only to repair a tenant whose stored credentials are out of sync; routine migrations do not need it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db migrate", options, async () => requestOxygen("/api/cli/db/migrate", {
+        await handleAsyncAction("db migrate", options, () => requestOxygen("/api/cli/db/migrate", {
             method: "POST",
             body: options.rotateCredentials ? { rotate_credentials: true } : {},
         }));
@@ -628,7 +868,7 @@ export function createProgram() {
         .option("--dry-run", "List pending tenants without applying migrations.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db migrate-all", options, async () => {
+        await handleAsyncAction("db migrate-all", options, () => {
             const limit = readPositiveInt(options.limit);
             return requestOxygen("/api/cli/db/migrate-all", {
                 method: "POST",
@@ -704,14 +944,14 @@ export function createProgram() {
         .description("Show tenant database cost controls and reconciliation status.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db cost-policy", options, async () => requestOxygen("/api/cli/db/cost-policy"));
+        await handleAsyncAction("db cost-policy", options, () => requestOxygen("/api/cli/db/cost-policy"));
     }))
         .addCommand(new Command("reconcile-cost-policy")
         .description("Apply tenant database cost controls to the managed Neon endpoint.")
         .option("--suspend-idle", "Request immediate Neon compute suspension when the tenant is idle.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db reconcile-cost-policy", options, async () => requestOxygen("/api/cli/db/reconcile-cost-policy", {
+        await handleAsyncAction("db reconcile-cost-policy", options, () => requestOxygen("/api/cli/db/reconcile-cost-policy", {
             method: "POST",
             body: {
                 ...(options.suspendIdle ? { suspend_idle: true } : {}),
@@ -723,7 +963,7 @@ export function createProgram() {
         .requiredOption("--database-url <url>", "Owner connection string for the tenant Postgres database.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db attach", options, async () => requestOxygen("/api/cli/db/attach", {
+        await handleAsyncAction("db attach", options, () => requestOxygen("/api/cli/db/attach", {
             method: "POST",
             body: { database_url: options.databaseUrl },
         }));
@@ -734,7 +974,7 @@ export function createProgram() {
         .option("--max-rows <n>", "Maximum rows to return. Defaults to 100; hard cap is 1000.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("db query", options, async () => {
+        await handleAsyncAction("db query", options, () => {
             const maxRows = readPositiveInt(options.maxRows);
             return requestOxygen("/api/cli/db/query", {
                 method: "POST",
@@ -752,18 +992,87 @@ export function createProgram() {
         .description("List table projects in the current tenant database.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("projects list", options, async () => requestOxygen("/api/cli/projects"));
+        await handleAsyncAction("projects list", options, () => requestOxygen("/api/cli/projects"));
     }))
         .addCommand(new Command("create")
         .description("Create a schema-backed table project.")
         .argument("<name>", "Display name for the project.")
         .option("--json", "Print a JSON envelope.")
         .action(async (name, options) => {
-        await handleAsyncAction("projects create", options, async () => requestOxygen("/api/cli/projects", {
+        await handleAsyncAction("projects create", options, () => requestOxygen("/api/cli/projects", {
             method: "POST",
             body: { name },
         }));
     }));
+    program
+        .command("crm")
+        .description("Agent-native CRM object setup and metadata commands.")
+        .addCommand(new Command("setup")
+        .description("Create or repair standard CRM object-backed tables. Defaults to dry-run.")
+        .option("--objects <objects>", "Comma-separated standard CRM objects to set up. Defaults to companies,people.")
+        .option("--project <project>", "Project id or slug for created CRM tables.")
+        .option("--dry-run", "Preview CRM setup without creating or repairing tables.")
+        .option("--live", "Apply CRM setup changes. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm setup", options, () => requestOxygen("/api/cli/crm/setup", {
+            method: "POST",
+            body: buildCrmSetupBody(options),
+        }));
+    }))
+        .addCommand(new Command("objects")
+        .description("List configured CRM objects in the current tenant database.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("crm objects", options, () => requestOxygen("/api/cli/crm/objects"));
+    }))
+        .addCommand(new Command("assert")
+        .description("Create or update one CRM record by object identity. Defaults to dry-run.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .requiredOption("--identity <key=value>", "Identity key/value, for example domain=acme.com or email=ceo@acme.com.")
+        .option("--values-json <json>", "JSON object of CRM attribute values keyed by column key.")
+        .option("--dry-run", "Preview the assert without writing a row.")
+        .option("--live", "Apply the assert. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, options) => {
+        await handleAsyncAction("crm assert", options, () => requestOxygen("/api/cli/crm/assert", {
+            method: "POST",
+            body: buildCrmAssertBody(object, options),
+        }));
+    }))
+        .addCommand(new Command("get")
+        .description("Get one CRM record aggregate with row values, identities, and relationships.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<row_id>", "CRM record row id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm get", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}`));
+    }))
+        .addCommand(new Command("relationships")
+        .description("Manage CRM record relationships.")
+        .addCommand(new Command("upsert")
+        .description("Create or replace a CRM relationship edge. Defaults to dry-run.")
+        .argument("<object>", "Source CRM object slug, such as companies or people.")
+        .argument("<row_id>", "Source CRM record row id.")
+        .requiredOption("--relationship <slug>", "Relationship slug from the source object, such as team or company.")
+        .option("--target-object <object>", "Target CRM object slug. Optional when the relationship has one target.")
+        .requiredOption("--target-row-id <row_id>", "Target CRM record row id.")
+        .option("--dry-run", "Preview the relationship write without changing edges.")
+        .option("--live", "Apply the relationship write. Default is dry-run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm relationships upsert", options, () => requestOxygen("/api/cli/crm/relationships/upsert", {
+            method: "POST",
+            body: buildCrmRelationshipUpsertBody(object, rowId, options),
+        }));
+    })))
+        .addCommand(new Command("describe")
+        .description("Describe one configured CRM object.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, options) => {
+        await handleAsyncAction("crm describe", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}`));
+    }));
     const tablesCommand = program
         .command("tables")
         .description("Tenant workspace table commands.")
@@ -774,7 +1083,7 @@ export function createProgram() {
         .option("--project <project>", "Project id or slug. Defaults to General.")
         .option("--json", "Print a JSON envelope.")
         .action(async (name, options) => {
-        await handleAsyncAction("tables create", options, async () => requestOxygen("/api/cli/tables", {
+        await handleAsyncAction("tables create", options, () => requestOxygen("/api/cli/tables", {
             method: "POST",
             body: {
                 name,
@@ -790,7 +1099,7 @@ export function createProgram() {
         .option("--schema-only", "Duplicate columns and definitions without copying row values.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables duplicate", options, async () => requestOxygen("/api/cli/tables/duplicate", {
+        await handleAsyncAction("tables duplicate", options, () => requestOxygen("/api/cli/tables/duplicate", {
             method: "POST",
             body: {
                 table,
@@ -805,7 +1114,7 @@ export function createProgram() {
         .requiredOption("--rows-json <json>", "JSON array of row objects keyed by column key.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables insert", options, async () => requestOxygen("/api/cli/tables/rows", {
+        await handleAsyncAction("tables insert", options, () => requestOxygen("/api/cli/tables/rows", {
             method: "POST",
             body: {
                 table,
@@ -820,7 +1129,7 @@ export function createProgram() {
         .requiredOption("--values-json <json>", "JSON object of values keyed by column key.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, rowId, options) => {
-        await handleAsyncAction("tables update", options, async () => requestOxygen("/api/cli/tables/rows/update", {
+        await handleAsyncAction("tables update", options, () => requestOxygen("/api/cli/tables/rows/update", {
             method: "POST",
             body: {
                 table,
@@ -835,7 +1144,7 @@ export function createProgram() {
         .argument("<row_id>", "Workspace row UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, rowId, options) => {
-        await handleAsyncAction("tables delete-row", options, async () => requestOxygen("/api/cli/tables/rows/delete", {
+        await handleAsyncAction("tables delete-row", options, () => requestOxygen("/api/cli/tables/rows/delete", {
             method: "POST",
             body: {
                 table,
@@ -873,7 +1182,7 @@ export function createProgram() {
         .option("--dry-run", "Preview inserts, updates, duplicate keys, and field conflicts without writing rows.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables upsert", options, async () => requestOxygen("/api/cli/tables/rows/upsert", {
+        await handleAsyncAction("tables upsert", options, () => requestOxygen("/api/cli/tables/rows/upsert", {
             method: "POST",
             body: {
                 table,
@@ -899,7 +1208,7 @@ export function createProgram() {
         .option("--max-concurrency <n>", "Maximum concurrent import chunks for background mode. Defaults to 5.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables import", options, async () => importRows(table, options));
+        await handleAsyncAction("tables import", options, () => importRows(table, options));
     }))
         .addCommand(new Command("export")
         .description("Export workspace table rows as JSON, JSONL, CSV, or a human-readable table.")
@@ -909,7 +1218,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum rows to export. Defaults to 100; hard cap is 1000.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables export", options, async () => exportRows(table, options));
+        await handleAsyncAction("tables export", options, () => exportRows(table, options));
     }))
         .addCommand(new Command("export-bundle")
         .description("Export a workspace table as a portable bundle (schema + every row) for cross-environment / cross-org copies.")
@@ -918,7 +1227,7 @@ export function createProgram() {
         .option("--page-size <n>", "Rows per cursor-paginated request. Defaults to 500; hard cap is 1000.")
         .option("--json", "Print a JSON envelope (omit row payload — use --output to keep the rows).")
         .action(async (table, options) => {
-        await handleAsyncAction("tables export-bundle", options, async () => exportTableBundle(table, options));
+        await handleAsyncAction("tables export-bundle", options, () => exportTableBundle(table, options));
     }))
         .addCommand(new Command("import-bundle")
         .description("Recreate a workspace table from an export-bundle file in this org. Restores columns (incl. enrichment/tool definitions) and inserts every row. Pass --key to make the import idempotent (re-runnable), and --into to resume a failed import into the table it already created.")
@@ -930,14 +1239,14 @@ export function createProgram() {
         .option("--batch-size <n>", "Rows per write request. Defaults to 500; paid orgs may use up to 5000.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("tables import-bundle", options, async () => importTableBundle(options));
+        await handleAsyncAction("tables import-bundle", options, () => importTableBundle(options));
     }))
         .addCommand(new Command("list")
         .description("List workspace tables in the current tenant database.")
         .option("--project <project>", "Project id or slug to filter by.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("tables list", options, async () => requestOxygen(readOption(options.project)
+        await handleAsyncAction("tables list", options, () => requestOxygen(readOption(options.project)
             ? `/api/cli/tables?project=${encodeURIComponent(readOption(options.project))}`
             : "/api/cli/tables"));
     }))
@@ -947,12 +1256,20 @@ export function createProgram() {
         .option("--limit <n>", "Maximum rows to return. Defaults to 100; hard cap is 1000.")
         .option("--cursor <cursor>", "Pagination cursor returned by a previous query.")
         .option("--fields <columns>", "Comma-separated column keys or ids to include.")
-        .option("--filter-json <json>", "Filter object or array, e.g. '{\"column\":\"mobile_phone_e164\",\"op\":\"is_null\"}'.")
+        .option("--filter-json <json>", "Legacy filter object or array, e.g. '{\"column\":\"mobile_phone_e164\",\"op\":\"is_null\"}'. Mutually exclusive with --filter-tree-json/--sort-json.")
+        .option("--filter-tree-json <json>", "Airtable-style filter group, e.g. '{\"type\":\"group\",\"conjunction\":\"and\",\"children\":[{\"type\":\"leaf\",\"columnKey\":\"stage\",\"operator\":\"is\",\"value\":\"won\"}]}'. Mutually exclusive with --filter-json.")
+        .option("--sort-json <json>", "Ordered sort rules, e.g. '[{\"columnKey\":\"created_at\",\"direction\":\"desc\"}]'. Earlier rules dominate. Mutually exclusive with --filter-json.")
+        .option("--no-system-fields", "Omit _row_id, _created_at, and _updated_at from returned rows (included by default).")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables query", options, async () => {
+        await handleAsyncAction("tables query", options, () => {
             const limit = readPositiveInt(options.limit);
             const filters = readFilterJsonOption(options.filterJson);
+            const filterTree = readFilterTreeJsonOption(options.filterTreeJson);
+            const sorts = readSortJsonOption(options.sortJson);
+            if (filters && (filterTree || sorts)) {
+                throw new OxygenError("invalid_filter", "Pass either --filter-json (legacy) or --filter-tree-json/--sort-json, not both.", { exitCode: 1 });
+            }
             return requestOxygen("/api/cli/tables/query", {
                 method: "POST",
                 body: {
@@ -961,6 +1278,9 @@ export function createProgram() {
                     ...(readOption(options.cursor) ? { cursor: readOption(options.cursor) } : {}),
                     ...(readOption(options.fields) ? { fields: readCsvOption(options.fields) } : {}),
                     ...(filters ? { filters } : {}),
+                    ...(filterTree ? { filterTree } : {}),
+                    ...(sorts ? { sorts } : {}),
+                    ...(options.systemFields === false ? { include_system_fields: false } : {}),
                 },
             });
         });
@@ -996,13 +1316,27 @@ export function createProgram() {
         .option("--include-archived", "Include archived columns.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables describe", options, async () => requestOxygen("/api/cli/tables/describe", {
+        await handleAsyncAction("tables describe", options, () => requestOxygen("/api/cli/tables/describe", {
             method: "POST",
             body: {
                 table,
                 ...(options.includeArchived ? { include_archived: true } : {}),
             },
         }));
+    }))
+        .addCommand(new Command("activity")
+        .description("Show background runs active on a workspace table right now, with a worker-queue health rollup.")
+        .argument("<table>", "Table id or slug.")
+        .option("--limit <n>", "Maximum active runs to return (1-100). Defaults to 20.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("tables activity", options, () => {
+            const params = new URLSearchParams({ table });
+            const limit = readPositiveInt(options.limit);
+            if (limit)
+                params.set("limit", String(limit));
+            return requestOxygen(`/api/cli/tables/activity?${params.toString()}`);
+        });
     }))
         .addCommand(new Command("rename")
         .description("Rename a workspace table display name and slug.")
@@ -1010,7 +1344,7 @@ export function createProgram() {
         .requiredOption("--name <name>", "New table display name.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables rename", options, async () => requestOxygen("/api/cli/tables/rename", {
+        await handleAsyncAction("tables rename", options, () => requestOxygen("/api/cli/tables/rename", {
             method: "POST",
             body: { table, name: options.name },
         }));
@@ -1020,7 +1354,7 @@ export function createProgram() {
         .argument("<table>", "Table id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables archive", options, async () => requestOxygen("/api/cli/tables/archive", {
+        await handleAsyncAction("tables archive", options, () => requestOxygen("/api/cli/tables/archive", {
             method: "POST",
             body: { table },
         }));
@@ -1031,7 +1365,7 @@ export function createProgram() {
         .requiredOption("--project <project>", "Destination project id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables move", options, async () => requestOxygen("/api/cli/tables/move", {
+        await handleAsyncAction("tables move", options, () => requestOxygen("/api/cli/tables/move", {
             method: "POST",
             body: { table, project: options.project },
         }));
@@ -1042,7 +1376,7 @@ export function createProgram() {
         .option("--max-items <n>", "Max pending cache rows to poll in this run. Defaults to 1000.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("tables recover-pending", options, async () => {
+        await handleAsyncAction("tables recover-pending", options, () => {
             const maxItems = options.maxItems ? Number.parseInt(options.maxItems, 10) : undefined;
             return requestOxygen("/api/cli/tables/recover-pending", {
                 method: "POST",
@@ -1158,6 +1492,69 @@ export function createProgram() {
         autoRunStatus: options.autoRunStatus,
         limit: options.limit,
     }))))));
+    tablesCommand.addCommand(new Command("views")
+        .description("Create and manage saved table views (grid / kanban configurations).")
+        .addCommand(new Command("list")
+        .description("List a table's saved views.")
+        .argument("<table>", "Table id or slug.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => handleAsyncAction("tables views list", options, () => requestOxygen(`/api/cli/tables/views?table=${encodeURIComponent(table)}`))))
+        .addCommand(new Command("get")
+        .description("Get one saved view by id.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<view>", "View id.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, view, options) => handleAsyncAction("tables views get", options, () => requestOxygen(`/api/cli/tables/views?table=${encodeURIComponent(table)}&view=${encodeURIComponent(view)}`))))
+        .addCommand(new Command("create")
+        .description("Create a saved view.")
+        .argument("<table>", "Table id or slug.")
+        .requiredOption("--name <name>", "View name.")
+        .option("--view-type <type>", "table or kanban. Defaults to table.")
+        .option("--config <json>", "Advanced: raw JSON view config (filters, sorts, columns, group). Usually written by the app.")
+        .option("--default", "Make this the table's default view.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, options) => handleAsyncAction("tables views create", options, () => requestOxygen("/api/cli/tables/views", {
+        method: "POST",
+        body: {
+            table,
+            name: readOption(options.name),
+            ...(readOption(options.viewType) ? { view_type: readOption(options.viewType) } : {}),
+            ...(readOption(options.config)
+                ? { config: parseJsonValue(readOption(options.config) ?? "", "--config") }
+                : {}),
+            ...(options.default ? { is_default: true } : {}),
+        },
+    }))))
+        .addCommand(new Command("update")
+        .description("Update a saved view.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<view>", "View id.")
+        .option("--name <name>", "Rename the view.")
+        .option("--view-type <type>", "table or kanban.")
+        .option("--config <json>", "Advanced: raw JSON view config. Replaces the stored config.")
+        .option("--default", "Make this the table's default view.")
+        .option("--position <n>", "0-based order among the table's views.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, view, options) => handleAsyncAction("tables views update", options, () => requestOxygen("/api/cli/tables/views", {
+        method: "PATCH",
+        body: {
+            table,
+            view,
+            ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+            ...(readOption(options.viewType) ? { view_type: readOption(options.viewType) } : {}),
+            ...(readOption(options.config)
+                ? { config: parseJsonValue(readOption(options.config) ?? "", "--config") }
+                : {}),
+            ...(options.default ? { is_default: true } : {}),
+            ...(readOption(options.position) ? { position: Number(readOption(options.position)) } : {}),
+        },
+    }))))
+        .addCommand(new Command("delete")
+        .description("Delete a saved view by id.")
+        .argument("<table>", "Table id or slug.")
+        .argument("<view>", "View id.")
+        .option("--json", "Print a JSON envelope.")
+        .action((table, view, options) => handleAsyncAction("tables views delete", options, () => requestOxygen(`/api/cli/tables/views?table=${encodeURIComponent(table)}&view=${encodeURIComponent(view)}`, { method: "DELETE" })))));
     program
         .command("context")
         .description("Workspace-level GTM context commands.")
@@ -1172,7 +1569,7 @@ export function createProgram() {
         .option("--require-ready", "Exit with a conflict error when required context sections are missing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("context resolve", options, async () => requestOxygen("/api/cli/context/resolve", {
+        await handleAsyncAction("context resolve", options, () => requestOxygen("/api/cli/context/resolve", {
             method: "POST",
             body: buildContextResolveBody(options),
         }));
@@ -1183,7 +1580,7 @@ export function createProgram() {
         .description("Read the current workspace company profile.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("context profile get", options, async () => requestOxygen("/api/cli/context/profile"));
+        await handleAsyncAction("context profile get", options, () => requestOxygen("/api/cli/context/profile"));
     }))
         .addCommand(new Command("update")
         .description("Merge one or more profile sections into workspace GTM memory.")
@@ -1191,7 +1588,7 @@ export function createProgram() {
         .option("--summary <text>", "Optional concise summary for the profile.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("context profile update", options, async () => requestOxygen("/api/cli/context/profile/update", {
+        await handleAsyncAction("context profile update", options, () => requestOxygen("/api/cli/context/profile/update", {
             method: "POST",
             body: {
                 data: parseJsonObject(options.dataJson ?? "{}"),
@@ -1209,14 +1606,14 @@ export function createProgram() {
         .option("--include-archived", "Include archived assets when no status filter is set.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("context assets list", options, async () => requestOxygen(`/api/cli/context/assets${contextAssetsQuery(options)}`));
+        await handleAsyncAction("context assets list", options, () => requestOxygen(`/api/cli/context/assets${contextAssetsQuery(options)}`));
     }))
         .addCommand(new Command("get")
         .description("Read one context asset.")
         .argument("<asset_id>", "Context asset UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (assetId, options) => {
-        await handleAsyncAction("context asset get", options, async () => requestOxygen("/api/cli/context/assets/get", {
+        await handleAsyncAction("context asset get", options, () => requestOxygen("/api/cli/context/assets/get", {
             method: "POST",
             body: { id: assetId },
         }));
@@ -1234,7 +1631,7 @@ export function createProgram() {
         .option("--asset-json <json>", "Full asset JSON object. CLI flags override matching fields.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("context asset upsert", options, async () => requestOxygen("/api/cli/context/assets/upsert", {
+        await handleAsyncAction("context asset upsert", options, () => requestOxygen("/api/cli/context/assets/upsert", {
             method: "POST",
             body: buildContextAssetUpsertBody(options),
         }));
@@ -1244,7 +1641,7 @@ export function createProgram() {
         .argument("<asset_id>", "Context asset UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (assetId, options) => {
-        await handleAsyncAction("context asset archive", options, async () => requestOxygen("/api/cli/context/assets/archive", {
+        await handleAsyncAction("context asset archive", options, () => requestOxygen("/api/cli/context/assets/archive", {
             method: "POST",
             body: { id: assetId },
         }));
@@ -1298,10 +1695,10 @@ export function createProgram() {
             const body = { workflow_id: options.workflow };
             const tables = readOption(options.tables);
             if (tables)
-                body.table_ids = splitCsv(tables);
+                body.table_ids = readCsvOption(tables);
             const prompts = readOption(options.prompts);
             if (prompts)
-                body.prompt_slugs = splitCsv(prompts);
+                body.prompt_slugs = readCsvOption(prompts);
             const blueprintId = readOption(options.blueprintId);
             if (blueprintId)
                 body.blueprint_id = blueprintId;
@@ -1313,7 +1710,7 @@ export function createProgram() {
                 body.blueprint_summary = blueprintSummary;
             const blueprintTags = readOption(options.blueprintTags);
             if (blueprintTags)
-                body.blueprint_tags = splitCsv(blueprintTags);
+                body.blueprint_tags = readCsvOption(blueprintTags);
             const result = await requestOxygen("/api/cli/blueprints/export", {
                 method: "POST",
                 body,
@@ -1377,7 +1774,7 @@ export function createProgram() {
                 throw new Error("--file is required for blueprints save");
             const fs = await import("node:fs/promises");
             const raw = await fs.readFile(filePath, "utf8");
-            const envelope = JSON.parse(raw);
+            const envelope = parseJsonValue(raw, "--file");
             const body = { envelope };
             const slug = readOption(options.slug);
             if (slug)
@@ -1480,154 +1877,8 @@ export function createProgram() {
             return requestOxygen(`/api/blueprints/marketplace${qs}`, { requireAuth: false });
         });
     }));
-    program
-        .command("prompts")
-        .description("Reusable prompt templates layered into AI columns at run time.")
-        .addCommand(new Command("list")
-        .description("List prompt templates in the workspace.")
-        .option("--kind <kind>", "Filter by ai_column_system, scoring_rubric, or other.")
-        .option("--include-archived", "Include archived templates.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("prompts list", options, () => {
-            const params = new URLSearchParams();
-            const kind = readOption(options.kind);
-            if (kind)
-                params.set("kind", kind);
-            if (options.includeArchived)
-                params.set("include_archived", "true");
-            const qs = params.toString() ? `?${params.toString()}` : "";
-            return requestOxygen(`/api/cli/templates${qs}`);
-        });
-    }))
-        .addCommand(new Command("get")
-        .description("Read one prompt template by id or slug.")
-        .argument("<id_or_slug>", "Template UUID or slug.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (idOrSlug, options) => {
-        await handleAsyncAction("prompts get", options, () => requestOxygen("/api/cli/templates/get", {
-            method: "POST",
-            body: idOrSlug.includes("-") && idOrSlug.length >= 32
-                ? { id: idOrSlug }
-                : { slug: idOrSlug },
-        }));
-    }))
-        .addCommand(new Command("upsert")
-        .description("Create or update a prompt template.")
-        .option("--id <id>", "Existing template UUID to update. Omit to create.")
-        .option("--slug <slug>", "Stable slug (kebab-case).")
-        .option("--name <name>", "Human-readable name.")
-        .option("--description <text>", "Short description.")
-        .option("--kind <kind>", "Template kind: ai_column_system, scoring_rubric, or other.")
-        .option("--body <text>", "Prompt body.")
-        .option("--body-file <path>", "Path to a file containing the prompt body.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("prompts upsert", options, async () => {
-            const body = {};
-            if (readOption(options.id))
-                body.id = readOption(options.id);
-            if (readOption(options.slug))
-                body.slug = readOption(options.slug);
-            if (readOption(options.name))
-                body.name = readOption(options.name);
-            if (readOption(options.description) !== undefined)
-                body.description = readOption(options.description);
-            if (readOption(options.kind))
-                body.kind = readOption(options.kind);
-            if (readOption(options.body))
-                body.body = readOption(options.body);
-            else {
-                const path = readOption(options.bodyFile);
-                if (path) {
-                    const fs = await import("node:fs/promises");
-                    body.body = await fs.readFile(path, "utf8");
-                }
-            }
-            return requestOxygen("/api/cli/templates/upsert", { method: "POST", body });
-        });
-    }))
-        .addCommand(new Command("archive")
-        .description("Archive a prompt template. Seeded templates cannot be archived.")
-        .argument("<id>", "Template UUID.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (id, options) => {
-        await handleAsyncAction("prompts archive", options, () => requestOxygen("/api/cli/templates/archive", { method: "POST", body: { id } }));
-    }));
-    program
-        .command("templates")
-        .description("Deprecated alias for 'oxygen prompts'. Will be removed in a future release.")
-        .addCommand(new Command("list")
-        .description("List prompt templates in the workspace.")
-        .option("--kind <kind>", "Filter by ai_column_system, scoring_rubric, or other.")
-        .option("--include-archived", "Include archived templates.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("templates list", options, () => {
-            const params = new URLSearchParams();
-            const kind = readOption(options.kind);
-            if (kind)
-                params.set("kind", kind);
-            if (options.includeArchived)
-                params.set("include_archived", "true");
-            const qs = params.toString() ? `?${params.toString()}` : "";
-            return requestOxygen(`/api/cli/templates${qs}`);
-        });
-    }))
-        .addCommand(new Command("get")
-        .description("Read one prompt template by id or slug.")
-        .argument("<id_or_slug>", "Template UUID or slug.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (idOrSlug, options) => {
-        await handleAsyncAction("templates get", options, async () => requestOxygen("/api/cli/templates/get", {
-            method: "POST",
-            body: idOrSlug.includes("-") && idOrSlug.length >= 32
-                ? { id: idOrSlug }
-                : { slug: idOrSlug },
-        }));
-    }))
-        .addCommand(new Command("upsert")
-        .description("Create or update a prompt template.")
-        .option("--id <id>", "Existing template UUID to update. Omit to create.")
-        .option("--slug <slug>", "Stable slug (kebab-case).")
-        .option("--name <name>", "Human-readable name.")
-        .option("--description <text>", "Short description.")
-        .option("--kind <kind>", "Template kind: ai_column_system, scoring_rubric, or other.")
-        .option("--body <text>", "Prompt body.")
-        .option("--body-file <path>", "Path to a file containing the prompt body.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (options) => {
-        await handleAsyncAction("templates upsert", options, async () => {
-            const body = {};
-            if (readOption(options.id))
-                body.id = readOption(options.id);
-            if (readOption(options.slug))
-                body.slug = readOption(options.slug);
-            if (readOption(options.name))
-                body.name = readOption(options.name);
-            if (readOption(options.description) !== undefined)
-                body.description = readOption(options.description);
-            if (readOption(options.kind))
-                body.kind = readOption(options.kind);
-            if (readOption(options.body))
-                body.body = readOption(options.body);
-            else {
-                const path = readOption(options.bodyFile);
-                if (path) {
-                    const fs = await import("node:fs/promises");
-                    body.body = await fs.readFile(path, "utf8");
-                }
-            }
-            return requestOxygen("/api/cli/templates/upsert", { method: "POST", body });
-        });
-    }))
-        .addCommand(new Command("archive")
-        .description("Archive a prompt template. Seeded templates cannot be archived.")
-        .argument("<id>", "Template UUID.")
-        .option("--json", "Print a JSON envelope.")
-        .action(async (id, options) => {
-        await handleAsyncAction("templates archive", options, async () => requestOxygen("/api/cli/templates/archive", { method: "POST", body: { id } }));
-    }));
+    program.addCommand(buildPromptTemplatesCommand("prompts", "Reusable prompt templates layered into AI columns at run time."));
+    program.addCommand(buildPromptTemplatesCommand("templates", "Deprecated alias for 'oxygen prompts'. Will be removed in a future release."));
     program
         .command("reviews")
         .description("Human-in-the-loop reviews for AI-generated outreach messages.")
@@ -1672,7 +1923,7 @@ export function createProgram() {
         .argument("<review_id>", "Message review UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (reviewId, options) => {
-        await handleAsyncAction("reviews accept", options, async () => requestOxygen("/api/cli/message-reviews/decide", {
+        await handleAsyncAction("reviews accept", options, () => requestOxygen("/api/cli/message-reviews/decide", {
             method: "POST",
             body: { id: reviewId, decision: "accept" },
         }));
@@ -1688,7 +1939,7 @@ export function createProgram() {
             const body = { id: reviewId, decision: "reject" };
             const highlightsJson = readOption(options.highlightsJson);
             if (highlightsJson) {
-                body.highlights = JSON.parse(highlightsJson);
+                body.highlights = parseJsonValue(highlightsJson, "--highlights-json");
             }
             if (options.autoRerun)
                 body.auto_rerun = true;
@@ -1709,7 +1960,14 @@ export function createProgram() {
         .option("--definition-json <json>", "Optional JSON object with column definition metadata.")
         .option("--prompt-key <key>", "OXYGEN prompt-library key (e.g. email_draft_v1). Materializes prompt + output_schema and forces kind=ai.")
         .option("--input-mapping <json>", "Required with --prompt-key. JSON object mapping prompt input names to column or literal refs.")
-        .option("--json", "Print a JSON envelope.")
+        .option("--model <id>", "AI column model id (e.g. claude-sonnet-4-5). Explicit models require credentialMode byok unless allow-listed managed.")
+        .option("--reasoning-level <level>", "AI column reasoning level: low, medium, or high.")
+        .option("--run-condition <formula>", "Formula expression gating whether the AI column runs per row.")
+        .option("--run-condition-columns <csv>", "Comma-separated column keys referenced by --run-condition.")
+        .option("--output-schema-json <json>", "AI column output JSON schema as inline JSON.")
+        .option("--output-schema-file <path>", "AI column output JSON schema read from a file path.")
+        .option("--json", "Print a JSON envelope.")
+        // skipcq: JS-R1005 — intentional per-option branching to assemble the columns-add request body
         .action(async (table, options) => {
         if (!options.promptKey && !options.label) {
             throw new OxygenError("invalid_request", "--label is required.", { exitCode: 1 });
@@ -1730,12 +1988,20 @@ export function createProgram() {
             column.semantic_type = options.semanticType;
         if (options.definitionJson)
             column.definition = parseJsonObject(options.definitionJson);
+        if (readOption(options.model) ||
+            readOption(options.reasoningLevel) ||
+            readOption(options.runCondition) ||
+            readOption(options.outputSchemaJson) ||
+            readOption(options.outputSchemaFile)) {
+            const definition = isRecord(column.definition) ? column.definition : {};
+            column.definition = applyAiColumnConfig(definition, options);
+        }
         const body = { table, column };
         if (options.promptKey)
             body.prompt_key = options.promptKey;
         if (options.inputMapping)
             body.input_mapping = parseJsonObject(options.inputMapping);
-        await handleAsyncAction("columns add", options, async () => requestOxygen("/api/cli/tables/columns", {
+        await handleAsyncAction("columns add", options, () => requestOxygen("/api/cli/tables/columns", {
             method: "POST",
             body,
         }));
@@ -1755,6 +2021,7 @@ export function createProgram() {
         .option("--max-concurrency <n>", "Maximum concurrent row items for a background run. Defaults to 250 for AI columns and 50 otherwise.")
         .option("--local", "Run a custom HTTP column in this CLI process so env-var secrets stay local.")
         .option("--local-concurrency <n>", "Maximum concurrent custom HTTP requests for --local. Defaults to 3.")
+        .option("--dry-run", "Preview resolved model, credit estimate, and run-condition posture without spending any credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
         const limit = readPositiveInt(options.limit);
@@ -1778,7 +2045,8 @@ export function createProgram() {
                 exitCode: 1,
             });
         }
-        await handleAsyncAction("columns run", options, async () => {
+        // skipcq: JS-R1005 — intentional branching for local/background/filter column-run modes
+        await handleAsyncAction("columns run", options, () => {
             if (options.local) {
                 if (options.background) {
                     throw new OxygenError("invalid_column_run", "Pass either --local or --background, not both.", {
@@ -1809,6 +2077,7 @@ export function createProgram() {
                 ...(options.background ? { background: true } : {}),
                 ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
                 ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
+                ...(options.dryRun ? { dry_run: true } : {}),
             };
             return requestColumnsRun(body, table, {
                 background: Boolean(options.background),
@@ -1821,15 +2090,17 @@ export function createProgram() {
         .requiredOption("--column <column>", "Column id or key.")
         .requiredOption("--row <row_id>", "Row UUID.")
         .option("--from-review-id <review_id>", "Prior message review whose feedback to thread into the regeneration prompt.")
+        .option("--dry-run", "Preview the single-row credit estimate and posture without spending credits or writing a review.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("columns rerun", options, async () => requestOxygen("/api/cli/columns/rerun", {
+        await handleAsyncAction("columns rerun", options, () => requestOxygen("/api/cli/columns/rerun", {
             method: "POST",
             body: {
                 table: options.table,
                 column: options.column,
                 row_id: options.row,
                 ...(readOption(options.fromReviewId) ? { from_review_id: readOption(options.fromReviewId) } : {}),
+                ...(options.dryRun ? { dry_run: true } : {}),
             },
         }));
     }))
@@ -1844,7 +2115,7 @@ export function createProgram() {
         .action(async (table, sourceColumn, options) => {
         const mappings = options.mappingsJson ? parseJsonArray(options.mappingsJson) : undefined;
         const preset = readOption(options.preset);
-        await handleAsyncAction("columns materialize", options, async () => requestOxygen("/api/cli/tables/columns/materialize", {
+        await handleAsyncAction("columns materialize", options, () => requestOxygen("/api/cli/tables/columns/materialize", {
             method: "POST",
             body: {
                 table,
@@ -1863,7 +2134,7 @@ export function createProgram() {
         .option("--label <label>", "Optional new display label.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
-        await handleAsyncAction("columns rename", options, async () => requestOxygen("/api/cli/tables/columns/rename", {
+        await handleAsyncAction("columns rename", options, () => requestOxygen("/api/cli/tables/columns/rename", {
             method: "POST",
             body: {
                 table,
@@ -1880,9 +2151,26 @@ export function createProgram() {
         .option("--label <label>", "New display label.")
         .option("--semantic-type <type>", "New semantic type.")
         .option("--definition-json <json>", "Definition metadata to shallow-merge into the column; arrays are replaced wholesale and missing keys leave existing fields unchanged.")
+        .option("--model <id>", "AI column model id (e.g. claude-sonnet-4-5). Explicit models require credentialMode byok unless allow-listed managed.")
+        .option("--reasoning-level <level>", "AI column reasoning level: low, medium, or high.")
+        .option("--run-condition <formula>", "Formula expression gating whether the AI column runs per row.")
+        .option("--run-condition-columns <csv>", "Comma-separated column keys referenced by --run-condition.")
+        .option("--output-schema-json <json>", "AI column output JSON schema as inline JSON.")
+        .option("--output-schema-file <path>", "AI column output JSON schema read from a file path.")
         .option("--dry-run", "Return the would-be merged definition without writing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
+        const hasAiConfig = readOption(options.model) ||
+            readOption(options.reasoningLevel) ||
+            readOption(options.runCondition) ||
+            readOption(options.outputSchemaJson) ||
+            readOption(options.outputSchemaFile);
+        let definition = options.definitionJson
+            ? parseJsonObject(options.definitionJson)
+            : undefined;
+        if (hasAiConfig) {
+            definition = applyAiColumnConfig(definition ?? {}, options);
+        }
         await handleAsyncAction("columns update", options, () => requestOxygen("/api/cli/tables/columns/update", {
             method: "POST",
             body: {
@@ -1890,7 +2178,7 @@ export function createProgram() {
                 column,
                 ...(readOption(options.label) ? { label: readOption(options.label) } : {}),
                 ...(readOption(options.semanticType) ? { semantic_type: readOption(options.semanticType) } : {}),
-                ...(options.definitionJson ? { definition: parseJsonObject(options.definitionJson) } : {}),
+                ...(definition ? { definition } : {}),
                 ...(options.dryRun ? { dry_run: true } : {}),
             },
         }));
@@ -1903,7 +2191,7 @@ export function createProgram() {
         .option("--dry-run", "Preview the conversion (row counts and samples) without writing.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
-        await handleAsyncAction("columns retype", options, async () => requestOxygen("/api/cli/tables/columns/retype", {
+        await handleAsyncAction("columns retype", options, () => requestOxygen("/api/cli/tables/columns/retype", {
             method: "POST",
             body: {
                 table,
@@ -1919,7 +2207,7 @@ export function createProgram() {
         .argument("<column>", "Column id or key.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, column, options) => {
-        await handleAsyncAction("columns archive", options, async () => requestOxygen("/api/cli/tables/columns/archive", {
+        await handleAsyncAction("columns archive", options, () => requestOxygen("/api/cli/tables/columns/archive", {
             method: "POST",
             body: { table, column },
         }));
@@ -1938,7 +2226,7 @@ export function createProgram() {
         .option("--dry-run", "Preview the provider action column without creating it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("action-column add-provider", options, async () => {
+        await handleAsyncAction("action-column add-provider", options, () => {
             const tableId = readOption(table) ?? readOption(options.table);
             if (!tableId) {
                 throw new OxygenError("invalid_request", "Pass a table argument or --table <table>.", {
@@ -1983,7 +2271,7 @@ export function createProgram() {
         const maxCredits = readPositiveNumber(options.maxCredits);
         const maxConcurrency = readPositiveInt(options.maxConcurrency);
         const chainSteps = readChainStepsOption(options.thenJson);
-        await handleAsyncAction("table-runs create", options, async () => requestOxygen("/api/cli/table-action-runs", {
+        await handleAsyncAction("table-runs create", options, () => requestOxygen("/api/cli/table-action-runs", {
             method: "POST",
             body: {
                 table,
@@ -2012,7 +2300,7 @@ export function createProgram() {
         .argument("<run_id>", "Table action run UUID or parent workspace run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs get", options, async () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}`));
+        await handleAsyncAction("table-runs get", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}`));
     }))
         .addCommand(new Command("items")
         .description("List row items for a durable table action run.")
@@ -2021,7 +2309,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum items to return. Defaults to 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs items", options, async () => {
+        await handleAsyncAction("table-runs items", options, () => {
             const query = new URLSearchParams();
             if (readOption(options.status))
                 query.set("status", readOption(options.status) ?? "");
@@ -2039,21 +2327,21 @@ export function createProgram() {
         .option("--interval-seconds <n>", "Polling interval. Defaults to 5.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs wait", options, async () => waitForTableActionRun(runId, options));
+        await handleAsyncAction("table-runs wait", options, () => waitForTableActionRun(runId, options));
     }))
         .addCommand(new Command("provider-summary")
         .description("Summarize provider attempts, upstream request events, and credit capture/release for a table action run.")
         .argument("<run_id>", "Table action run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs provider-summary", options, async () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/provider-summary`));
+        await handleAsyncAction("table-runs provider-summary", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/provider-summary`));
     }))
         .addCommand(new Command("cancel")
         .description("Request cancellation for a durable table action run.")
         .argument("<run_id>", "Table action run UUID or parent workspace run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs cancel", options, async () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/cancel`, {
+        await handleAsyncAction("table-runs cancel", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/cancel`, {
             method: "POST",
             body: {},
         }));
@@ -2063,7 +2351,7 @@ export function createProgram() {
         .argument("<run_id>", "Table action run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs pause", options, async () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/pause`, {
+        await handleAsyncAction("table-runs pause", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/pause`, {
             method: "POST",
             body: {},
         }));
@@ -2073,7 +2361,7 @@ export function createProgram() {
         .argument("<run_id>", "Table action run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs resume", options, async () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/resume`, {
+        await handleAsyncAction("table-runs resume", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/resume`, {
             method: "POST",
             body: {},
         }));
@@ -2083,7 +2371,7 @@ export function createProgram() {
         .argument("<run_id>", "Table action run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-runs retry-failed", options, async () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/retry-failed`, {
+        await handleAsyncAction("table-runs retry-failed", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/retry-failed`, {
             method: "POST",
             body: {},
         }));
@@ -2108,7 +2396,7 @@ export function createProgram() {
         .option("--metadata-json <json>", "Optional metadata object to attach to the run.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("table-ingestions create-tool-page", options, async () => {
+        await handleAsyncAction("table-ingestions create-tool-page", options, () => {
             const toolId = readOption(options.tool) ?? readOption(options.toolId);
             if (!toolId) {
                 throw new OxygenError("invalid_table_ingestion", "Pass --tool or --tool-id.", {
@@ -2155,7 +2443,7 @@ export function createProgram() {
         .argument("<run_id>", "Table ingestion run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-ingestions get", options, async () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}`));
+        await handleAsyncAction("table-ingestions get", options, () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}`));
     }))
         .addCommand(new Command("items")
         .description("List items for a durable table ingestion run.")
@@ -2164,7 +2452,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum items to return. Defaults to 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-ingestions items", options, async () => {
+        await handleAsyncAction("table-ingestions items", options, () => {
             const query = new URLSearchParams();
             if (readOption(options.status))
                 query.set("status", readOption(options.status) ?? "");
@@ -2182,14 +2470,14 @@ export function createProgram() {
         .option("--interval-seconds <n>", "Polling interval. Defaults to 5.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-ingestions wait", options, async () => waitForTableIngestionRun(runId, options));
+        await handleAsyncAction("table-ingestions wait", options, () => waitForTableIngestionRun(runId, options));
     }))
         .addCommand(new Command("cancel")
         .description("Request cancellation for a durable table ingestion run.")
         .argument("<run_id>", "Table ingestion run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-ingestions cancel", options, async () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/cancel`, {
+        await handleAsyncAction("table-ingestions cancel", options, () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/cancel`, {
             method: "POST",
             body: {},
         }));
@@ -2199,7 +2487,7 @@ export function createProgram() {
         .argument("<run_id>", "Table ingestion run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("table-ingestions retry-failed", options, async () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/retry-failed`, {
+        await handleAsyncAction("table-ingestions retry-failed", options, () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/retry-failed`, {
             method: "POST",
             body: {},
         }));
@@ -2234,7 +2522,7 @@ export function createProgram() {
         .option("--materialize-preview", "Create a preview table for the plan. Defaults to no table side effect.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("lead-sourcing plan", options, async () => requestOxygen("/api/cli/lead-sourcing/plan", {
+        await handleAsyncAction("lead-sourcing plan", options, () => requestOxygen("/api/cli/lead-sourcing/plan", {
             method: "POST",
             body: {
                 prompt: readFileIfPresent(options.prompt),
@@ -2248,7 +2536,7 @@ export function createProgram() {
         .requiredOption("--spec <file>", "JSON LeadSourcingSpec file, or a text prompt file to compile into a spec.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("lead-sourcing audit", options, async () => requestOxygen("/api/cli/lead-sourcing/audit", {
+        await handleAsyncAction("lead-sourcing audit", options, () => requestOxygen("/api/cli/lead-sourcing/audit", {
             method: "POST",
             body: {
                 table,
@@ -2262,7 +2550,7 @@ export function createProgram() {
         .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: people_search, signal_search, web_search, web_scrape, local_business_search, or source_specific_scrape. For company search use 'oxygen companies search plan'.")
+        .option("--kind <kind>", "Route kind: signal_search, web_search, web_scrape, local_business_search, or source_specific_scrape. For people search use 'oxygen people search plan'; 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.")
@@ -2271,6 +2559,7 @@ export function createProgram() {
         .action(async (options) => {
         await handleAsyncAction("search plan", options, () => {
             assertNotCompanySearchKind(options.kind);
+            assertNotPeopleSearchKind(options.kind);
             return requestOxygen("/api/cli/search/plan", {
                 method: "POST",
                 body: {
@@ -2385,7 +2674,7 @@ export function createProgram() {
         .description("Compile a company-search prompt into ordered provider routes without provider calls.")
         .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("--source-intent <intent>", "Override detected intent: sizing, structured, lookalike, 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.")
@@ -2398,7 +2687,7 @@ export function createProgram() {
         .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("--estimate", "Run a free server-side preflight pass: resolves provider enums and a free count probe for an estimated match count (zero credits).")
         .option("--materialize-preview", "Create a preview table with route rows.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -2432,7 +2721,7 @@ export function createProgram() {
         .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("--estimate", "Run a free server-side preflight pass when planning from --prompt: resolves provider enums and a free count probe (zero credits).")
         .option("--approved", "Required for live runs after inspecting dry-run output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -2455,7 +2744,7 @@ export function createProgram() {
         .option("--selection-json <json>", "Raw table action selection JSON.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("companies enrich preview", options, async () => requestOxygen("/api/cli/company-enrichment/preview", {
+        await handleAsyncAction("companies enrich preview", options, () => requestOxygen("/api/cli/company-enrichment/preview", {
             method: "POST",
             body: readCompaniesEnrichBody(table, options),
         }));
@@ -2475,7 +2764,7 @@ export function createProgram() {
         .option("--force", "Re-run the waterfall audit column even when it already has a value.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("companies enrich run", options, async () => requestOxygen("/api/cli/company-enrichment/run", {
+        await handleAsyncAction("companies enrich run", options, () => requestOxygen("/api/cli/company-enrichment/run", {
             method: "POST",
             body: readCompaniesEnrichBody(table, options),
         }));
@@ -2504,7 +2793,8 @@ export function createProgram() {
         .option("--require-email", "Only return people with a work email available (provider-dependent).")
         .option("--require-phone", "Only return people with a phone/mobile available (provider-dependent).")
         .option("--max-per-company <n>", "Cap on contacts per company for account-anchored searches.")
-        .option("--estimate", "Run a free count probe for an estimated match count.")
+        .option("--estimate", "Run a free count probe for an estimated match count (on by default).")
+        .option("--no-estimate", "Skip the default free count probe (people-search sizing is on by default).")
         .option("--materialize-preview", "Create a preview table with route rows.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -2540,7 +2830,8 @@ export function createProgram() {
         .option("--require-email", "Only return people with a work email available when planning from --prompt.")
         .option("--require-phone", "Only return people with a phone available when planning from --prompt.")
         .option("--max-per-company <n>", "Cap on contacts per company when planning from --prompt.")
-        .option("--estimate", "Run a free count probe when planning from --prompt.")
+        .option("--estimate", "Run a free count probe when planning from --prompt (on by default).")
+        .option("--no-estimate", "Skip the default 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) => {
@@ -2556,15 +2847,15 @@ export function createProgram() {
         .description("Show background action and ingestion queue health.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("worker queue-stats", options, async () => requestOxygen("/api/cli/worker/queue-stats"));
+        await handleAsyncAction("worker queue-stats", options, () => requestOxygen("/api/cli/worker/queue-stats"));
     }))
         .addCommand(new Command("failures")
         .description("List failed background action and ingestion items.")
-        .option("--queue <queue>", "all, actions, ingestions, or postgres_jobs. Defaults to all. Legacy aliases: bullmq, redis, jobs.")
+        .option("--queue <queue>", "all, actions, ingestions, or postgres_queue. Defaults to all. Legacy aliases: postgres_jobs, bullmq, redis, jobs.")
         .option("--limit <n>", "Maximum failed items per queue. Defaults to 25; server cap is 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("worker failures", options, async () => {
+        await handleAsyncAction("worker failures", options, () => {
             const query = new URLSearchParams();
             if (readOption(options.queue))
                 query.set("queue", readOption(options.queue) ?? "");
@@ -2579,7 +2870,7 @@ export function createProgram() {
         .description("Repair stale background action, ingestion, and workflow queue state.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("worker repair", options, async () => requestOxygen("/api/cli/worker/repair", {
+        await handleAsyncAction("worker repair", options, () => requestOxygen("/api/cli/worker/repair", {
             method: "POST",
             body: {},
         }));
@@ -2594,22 +2885,13 @@ export function createProgram() {
         .option("--recipe-timeout-ms <n>", "Compatibility option; ignored by the Postgres worker.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        const claimLimit = readPositiveInt(options.claimLimit);
-        const concurrency = readPositiveInt(options.concurrency);
-        const enrichmentConcurrency = readPositiveInt(options.enrichmentConcurrency);
-        const leaseSeconds = readPositiveInt(options.leaseSeconds);
-        const providerTimeoutMs = readPositiveInt(options.providerTimeoutMs);
-        const recipeTimeoutMs = readPositiveInt(options.recipeTimeoutMs);
-        await handleAsyncAction("worker run-once", options, async () => requestOxygen("/api/cli/worker/run-once", {
+        // The legacy tuning options are accepted for backward compatibility but
+        // intentionally ignored: the Postgres worker has no BullMQ knobs, and the
+        // route runs repairTenantWorkspaceQueues regardless of the request body.
+        // Send an empty body so we stop modeling ignored knobs as meaningful fields.
+        await handleAsyncAction("worker run-once", options, () => requestOxygen("/api/cli/worker/run-once", {
             method: "POST",
-            body: {
-                ...(claimLimit ? { claim_limit: claimLimit } : {}),
-                ...(concurrency ? { concurrency } : {}),
-                ...(enrichmentConcurrency ? { enrichment_concurrency: enrichmentConcurrency } : {}),
-                ...(leaseSeconds ? { lease_seconds: leaseSeconds } : {}),
-                ...(providerTimeoutMs ? { provider_timeout_ms: providerTimeoutMs } : {}),
-                ...(recipeTimeoutMs ? { recipe_timeout_ms: recipeTimeoutMs } : {}),
-            },
+            body: {},
         }));
     }));
     program
@@ -2619,7 +2901,7 @@ export function createProgram() {
         .description("Show the current plan and managed credit balance.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("billing balance", options, async () => requestOxygen("/api/cli/billing/balance"));
+        await handleAsyncAction("billing balance", options, () => requestOxygen("/api/cli/billing/balance"));
     }))
         .addCommand(new Command("usage")
         .description("Show credit ledger events.")
@@ -2637,7 +2919,7 @@ export function createProgram() {
         .option("--nonzero", "Only include events that changed available or reserved credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("billing usage", options, async () => {
+        await handleAsyncAction("billing usage", options, () => {
             const params = buildBillingLedgerParams(options);
             const suffix = params.toString() ? `?${params.toString()}` : "";
             return requestOxygen(`/api/cli/billing/usage${suffix}`);
@@ -2659,7 +2941,7 @@ export function createProgram() {
         .option("--nonzero", "Only include events that changed available or reserved credits. Default for audit except BYOK filters.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("billing audit", options, async () => {
+        await handleAsyncAction("billing audit", options, () => {
             const params = buildBillingLedgerParams(options);
             if (readOption(options.groupBy))
                 params.set("group_by", readOption(options.groupBy));
@@ -2676,7 +2958,7 @@ export function createProgram() {
         .option("--description <text>", "Ledger description for the admin grant.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("billing grant", options, async () => requestOxygen("/api/cli/billing/grant", {
+        await handleAsyncAction("billing grant", options, () => requestOxygen("/api/cli/billing/grant", {
             method: "POST",
             body: {
                 credits: readPositiveNumber(options.credits),
@@ -2688,6 +2970,54 @@ export function createProgram() {
             },
         }));
     }));
+    program
+        .command("budget")
+        .description("Standing credit caps (org/table daily/monthly hard-blocks) beyond per-run max_credits.")
+        .addCommand(new Command("list")
+        .description("List the organization's standing budget policies.")
+        .option("--scope <scope>", "Filter by scope: org, table, api_key, workflow_trigger, monitor.")
+        .option("--status <status>", "Filter by status. Defaults to all.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("budget list", options, () => {
+            const params = new URLSearchParams();
+            if (readOption(options.scope))
+                params.set("scope", readOption(options.scope));
+            if (readOption(options.status))
+                params.set("status", readOption(options.status));
+            const suffix = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/budget${suffix}`);
+        });
+    }))
+        .addCommand(new Command("set")
+        .description("Set, raise, or lower a standing credit cap (idempotent per scope+window).")
+        .requiredOption("--scope <scope>", "org, table, api_key, workflow_trigger, or monitor.")
+        .requiredOption("--window <window>", "per_run, daily, or monthly.")
+        .requiredOption("--max-credits <credits>", "Cap in Oxygen credits.")
+        .option("--scope-id <id>", "Table id/slug for --scope table (or other scope id). Omit for a scope-wide cap.")
+        .option("--action <action>", "warn or hard_block. Defaults to hard_block.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("budget set", options, () => requestOxygen("/api/cli/budget", {
+            method: "POST",
+            body: {
+                scope: readOption(options.scope),
+                window: readOption(options.window),
+                max_credits: readPositiveNumber(options.maxCredits),
+                ...(readOption(options.scopeId) ? { scope_id: readOption(options.scopeId) } : {}),
+                ...(readOption(options.action) ? { action: readOption(options.action) } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("delete")
+        .description("Delete a standing budget policy by id.")
+        .requiredOption("--id <id>", "Budget policy id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("budget delete", options, () => requestOxygen(`/api/cli/budget?id=${encodeURIComponent(readOption(options.id))}`, {
+            method: "DELETE",
+        }));
+    }));
     program
         .command("admin")
         .description("Staff-only commands.")
@@ -2697,7 +3027,7 @@ export function createProgram() {
         .option("--credential-mode <mode>", "managed (default; real COGS), byok (customer-supplied credentials), or all.", "managed")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("admin costs", options, async () => {
+        await handleAsyncAction("admin costs", options, () => {
             const params = new URLSearchParams();
             const top = readPositiveInt(options.top);
             if (top)
@@ -2765,7 +3095,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum events to return. Defaults to 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("observability events", options, async () => {
+        await handleAsyncAction("observability events", options, () => {
             const params = new URLSearchParams();
             const status = readOption(options.status);
             const traceId = readOption(options.traceId);
@@ -2791,7 +3121,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum runs to return. Defaults to 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("runs list", options, async () => {
+        await handleAsyncAction("runs list", options, () => {
             const limit = readPositiveInt(options.limit);
             return requestOxygen(`/api/cli/runs${limit ? `?limit=${limit}` : ""}`);
         });
@@ -2801,7 +3131,7 @@ export function createProgram() {
         .argument("<run_id>", "Run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("runs get", options, async () => requestOxygen("/api/cli/runs/get", {
+        await handleAsyncAction("runs get", options, () => requestOxygen("/api/cli/runs/get", {
             method: "POST",
             body: { run_id: runId },
         }));
@@ -2816,7 +3146,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum changes to return. Defaults to 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, rowId, options) => {
-        await handleAsyncAction("rows history", options, async () => {
+        await handleAsyncAction("rows history", options, () => {
             const limit = readPositiveInt(options.limit);
             return requestOxygen("/api/cli/tables/rows/history", {
                 method: "POST",
@@ -2839,7 +3169,7 @@ export function createProgram() {
         .option("--history-limit <n>", "Maximum recent cell changes to include. Defaults to 10; cap 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, rowId, column, options) => {
-        await handleAsyncAction("cells inspect", options, async () => {
+        await handleAsyncAction("cells inspect", options, () => {
             const historyLimit = readPositiveInt(options.historyLimit);
             return requestOxygen("/api/cli/tables/cells/inspect", {
                 method: "POST",
@@ -2860,7 +3190,7 @@ export function createProgram() {
         .option("--limit <n>", "Maximum changes to return. Defaults to 50.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, rowId, column, options) => {
-        await handleAsyncAction("cells history", options, async () => {
+        await handleAsyncAction("cells history", options, () => {
             const limit = readPositiveInt(options.limit);
             return requestOxygen("/api/cli/tables/cells/history", {
                 method: "POST",
@@ -2885,6 +3215,7 @@ export function createProgram() {
         .option("--session-id <id>", "Session id to update. Defaults to the current session.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
+        // skipcq: JS-0116 — async Promise-wraps the synchronous session helpers to satisfy handleAsyncAction's Promise<unknown> action
         await handleAsyncAction("session start", options, async () => {
             const updateIndex = readNonNegativeInt(options.update);
             if (updateIndex !== undefined) {
@@ -2912,6 +3243,7 @@ export function createProgram() {
         .option("--session-id <id>", "Session id. Defaults to the current session.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
+        // skipcq: JS-0116 — async Promise-wraps the synchronous addSessionStatus helper to satisfy handleAsyncAction's Promise<unknown> action
         await handleAsyncAction("session status", options, async () => addSessionStatus({
             sessionId: readOption(options.sessionId),
             message: options.message,
@@ -2928,6 +3260,7 @@ export function createProgram() {
         .option("--session-id <id>", "Session id. Defaults to the current session.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
+        // skipcq: JS-0116 — async Promise-wraps the synchronous addSessionOutput helper to satisfy handleAsyncAction's Promise<unknown> action
         await handleAsyncAction("session output", options, async () => addSessionOutput({
             sessionId: readOption(options.sessionId),
             csv: readOption(options.csv),
@@ -2942,6 +3275,7 @@ export function createProgram() {
         .option("--session-id <id>", "Session id. Defaults to the current session.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
+        // skipcq: JS-0116 — async Promise-wraps the synchronous getSessionUsage helper to satisfy handleAsyncAction's Promise<unknown> action
         await handleAsyncAction("session usage", options, async () => getSessionUsage({ sessionId: readOption(options.sessionId) }));
     }));
     program
@@ -3011,7 +3345,7 @@ export function createProgram() {
         .argument("<tool_id>", "Tool id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (toolId, options) => {
-        await handleAsyncAction("tools get", options, async () => requestOxygen(`/api/cli/tools/${encodeURIComponent(toolId)}`));
+        await handleAsyncAction("tools get", options, () => requestOxygen(`/api/cli/tools/${encodeURIComponent(toolId)}`));
     }))
         .addCommand(new Command("enums")
         .description("Provider enum catalogs for fields that accept normalized values.")
@@ -3062,8 +3396,11 @@ export function createProgram() {
         .option("--return <mode>", "Legacy response shape: raw, compact, or summary. Defaults to raw.")
         .option("--return-mode <mode>", "Response shape: raw, compact, or summary. Prefer summary for large search responses.")
         .option("--oxygen-cursor <cursor>", "Short Oxygen cursor returned as oxygen_next_cursor by a previous tool run.")
+        .option("--max-credits <n>", "Required credit ceiling for live runs of paid tools.")
+        .option("--approved", "Required for live runs of paid tools after inspecting dry-run output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (toolId, options) => {
+        const maxCredits = readPositiveNumber(options.maxCredits);
         await handleAsyncAction("tools run", options, () => requestOxygen("/api/cli/tools/run", {
             method: "POST",
             body: {
@@ -3078,6 +3415,8 @@ export function createProgram() {
                 ...(readOption(options["return"]) ? { return: readOption(options["return"]) } : {}),
                 ...(readOption(options.returnMode) ? { return_mode: readOption(options.returnMode) } : {}),
                 ...(readOption(options.oxygenCursor) ? { oxygen_cursor: readOption(options.oxygenCursor) } : {}),
+                ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                ...(options.approved ? { approved: true } : {}),
             },
         }));
     }));
@@ -3104,6 +3443,7 @@ export function createProgram() {
         .option("--email-pattern-validation <mode>", "Work-email pattern pre-step: leadmagic_valid_only or disabled.")
         .option("--phone-waterfall-profile <profile>", "Phone waterfall profile: auto (input-aware), linkedin_url, email, or name_domain. Auto picks the cheapest cost-ordered provider set for each row's inputs (mobile match rate ~30-60%).")
         .option("--verify-phone", "Validate found phone numbers with ClearoutPhone (adds phone_line_type + phone_carrier; filter phone_line_type=mobile for mobile-only).")
+        .option("--allow-premium-lanes", "Opt in to premium high-cost lanes (e.g. >25cr/row phone reveal). Off by default: premium lanes are skipped so an unattended run can't bill-shock.")
         .option("--phone-verification-credential-mode <mode>", "ClearoutPhone credential mode for phone verification: managed or user_api_key.")
         .option("--limit <n>", "Rows to estimate. Defaults to 10.")
         .option("--all", "Estimate all rows.")
@@ -3112,7 +3452,7 @@ export function createProgram() {
         .option("--only-missing", "Estimate rows missing the capability's normalized output when no explicit selection is passed.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
-        await handleAsyncAction("enrich-column preview", options, async () => requestOxygen("/api/cli/enrich-column/preview", {
+        await handleAsyncAction("enrich-column preview", options, () => requestOxygen("/api/cli/enrich-column/preview", {
             method: "POST",
             body: buildEnrichColumnBody(table, options),
         }));
@@ -3138,6 +3478,7 @@ export function createProgram() {
         .option("--email-pattern-validation <mode>", "Work-email pattern pre-step: leadmagic_valid_only or disabled.")
         .option("--phone-waterfall-profile <profile>", "Phone waterfall profile: auto (input-aware), linkedin_url, email, or name_domain. Auto picks the cheapest cost-ordered provider set for each row's inputs (mobile match rate ~30-60%).")
         .option("--verify-phone", "Validate found phone numbers with ClearoutPhone (adds phone_line_type + phone_carrier; filter phone_line_type=mobile for mobile-only).")
+        .option("--allow-premium-lanes", "Opt in to premium high-cost lanes (e.g. >25cr/row phone reveal). Off by default: premium lanes are skipped so an unattended run can't bill-shock.")
         .option("--phone-verification-credential-mode <mode>", "ClearoutPhone credential mode for phone verification: managed or user_api_key.")
         .option("--limit <n>", "Rows to queue.")
         .option("--all", "Queue all rows.")
@@ -3149,7 +3490,7 @@ export function createProgram() {
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
         const maxConcurrency = readPositiveInt(options.maxConcurrency);
-        await handleAsyncAction("enrich-column run", options, async () => requestOxygen("/api/cli/enrich-column/run", {
+        await handleAsyncAction("enrich-column run", options, () => requestOxygen("/api/cli/enrich-column/run", {
             method: "POST",
             body: {
                 ...buildEnrichColumnBody(table, options),
@@ -3159,6 +3500,62 @@ export function createProgram() {
             },
         }));
     }));
+    program
+        .command("find")
+        .description("One-shot contact and company lookups over enrichment waterfalls (no table). dry_run previews for free; live spends and needs --max-credits.")
+        .addCommand(new Command("email")
+        .description("Find a person's work email via an input-aware multi-provider waterfall: a LinkedIn URL, name+domain, or first/last+domain each select the best provider profile, with an email-pattern pre-step and verification. dry_run shows the resolved profile + chain for free.")
+        .option("--linkedin-url <url>", "Person LinkedIn profile URL (strongest signal).")
+        .option("--full-name <name>", "Person full name.")
+        .option("--first-name <name>", "Person first name.")
+        .option("--last-name <name>", "Person last name.")
+        .option("--company-domain <domain>", "Company apex domain, e.g. acme.com.")
+        .option("--company-name <name>", "Company name.")
+        .option("--mode <mode>", "dry_run (default) or live. live spends credits.")
+        .option("--max-credits <credits>", "Spend ceiling. Required for --mode live.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("find email", options, () => requestOxygen("/api/cli/find/run", { method: "POST", body: buildFindBody("email", options) }));
+    }))
+        .addCommand(new Command("phone")
+        .description("Find a person's mobile phone via a multi-provider waterfall. The provider chain is input-aware: a LinkedIn URL unlocks the full cost-ordered chain (Blitz first), email/name use the providers that accept them.")
+        .option("--linkedin-url <url>", "Person LinkedIn profile URL (strongest signal for phone).")
+        .option("--email <email>", "Known email as an identity fallback.")
+        .option("--full-name <name>", "Person full name.")
+        .option("--company-domain <domain>", "Company apex domain.")
+        .option("--company-name <name>", "Company name.")
+        .option("--verify", "Verify the found number with ClearoutPhone — adds line_type/carrier and keeps the number on a non-verdict (only a genuine 'not valid' is discarded).")
+        .option("--mode <mode>", "dry_run (default) or live. live spends credits.")
+        .option("--max-credits <credits>", "Spend ceiling. Required for --mode live.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("find phone", options, () => requestOxygen("/api/cli/find/run", { method: "POST", body: buildFindBody("phone", options) }));
+    }))
+        .addCommand(new Command("linkedin")
+        .description("Resolve a person's LinkedIn URL from name + company (or email), with identity validation.")
+        .option("--full-name <name>", "Person full name.")
+        .option("--email <email>", "Known email.")
+        .option("--company-domain <domain>", "Company apex domain.")
+        .option("--company-name <name>", "Company name.")
+        .option("--company-linkedin-url <url>", "Company LinkedIn URL.")
+        .option("--mode <mode>", "dry_run (default) or live. live spends credits.")
+        .option("--max-credits <credits>", "Spend ceiling. Required for --mode live.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("find linkedin", options, () => requestOxygen("/api/cli/find/run", { method: "POST", body: buildFindBody("linkedin", options) }));
+    }))
+        .addCommand(new Command("company")
+        .description("Enrich a company (domain/linkedin/headcount/industry/funding/tech/hiring/profile) via a waterfall.")
+        .option("--domain <domain>", "Company apex domain.")
+        .option("--name <name>", "Company name.")
+        .option("--linkedin-url <url>", "Company LinkedIn URL.")
+        .option("--fields <fields>", "Comma-separated company fields. Defaults to domain,linkedin_url,headcount,industry.")
+        .option("--mode <mode>", "dry_run (default) or live. live spends credits.")
+        .option("--max-credits <credits>", "Spend ceiling. Required for --mode live.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("find company", options, () => requestOxygen("/api/cli/find/run", { method: "POST", body: buildFindBody("company", options) }));
+    }));
     program
         .command("enrichment")
         .description("High-level enrichment column definition helpers.")
@@ -3190,7 +3587,7 @@ export function createProgram() {
         .option("--toolkit <id>", "Filter by toolkit / integration id, such as gmail.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("integrations events list", options, async () => {
+        await handleAsyncAction("integrations events list", options, () => {
             const query = new URLSearchParams();
             if (readOption(options.source))
                 query.set("source", readOption(options.source) ?? "");
@@ -3210,22 +3607,17 @@ export function createProgram() {
         .option("--trigger-config <json>", "JSON object passed to the provider when registering the trigger (Composio triggers only).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("integrations events enable", options, async () => {
+        await handleAsyncAction("integrations events enable", options, () => {
             const triggerConfigRaw = readOption(options.triggerConfig);
             let triggerConfig;
             if (triggerConfigRaw) {
-                try {
-                    const parsed = JSON.parse(triggerConfigRaw);
-                    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-                        throw new Error("--trigger-config must be a JSON object.");
-                    }
-                    triggerConfig = parsed;
-                }
-                catch (error) {
-                    throw new Error(error instanceof Error
-                        ? `Invalid --trigger-config: ${error.message}`
-                        : "Invalid --trigger-config");
+                const parsed = parseJsonValue(triggerConfigRaw, "--trigger-config");
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                    throw new OxygenError("invalid_request", "--trigger-config must be a JSON object.", {
+                        exitCode: 1,
+                    });
                 }
+                triggerConfig = parsed;
             }
             return requestOxygen("/api/cli/integrations/events/enable", {
                 method: "POST",
@@ -3245,7 +3637,7 @@ export function createProgram() {
         .option("--connection-id <connection_id>", "Specific integration connection id. Defaults to the active default connection.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("integrations events disable", options, async () => requestOxygen("/api/cli/integrations/events/disable", {
+        await handleAsyncAction("integrations events disable", options, () => requestOxygen("/api/cli/integrations/events/disable", {
             method: "POST",
             body: {
                 source: readOption(options.source),
@@ -3285,21 +3677,24 @@ export function createProgram() {
         .description("List supported integrations and this org's connections.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("integrations list", options, async () => requestOxygen("/api/cli/integrations/composio/list"));
+        await handleAsyncAction("integrations list", options, () => requestOxygen("/api/cli/integrations/composio/list"));
     }))
         .addCommand(new Command("connect")
         .description("Connect an integration. OAuth toolkits return a redirect URL; API-key integrations accept --api-key.")
         .argument("<integration_id>", "Integration id, such as 'slack' or 'serpapi'.")
         .option("--api-key <value>", "API key for Composio API-key toolkits (e.g. SerpAPI, Resend).")
+        .option("--account-id <id>", "Provider account id for integrations that span multiple accounts (e.g. Cloudflare when the token can access more than one account).")
         .option("--json", "Print a JSON envelope.")
         .action(async (integrationId, options) => {
-        await handleAsyncAction("integrations connect", options, async () => {
+        await handleAsyncAction("integrations connect", options, () => {
             const apiKey = readOption(options.apiKey)?.trim();
+            const accountId = readOption(options.accountId);
             return requestOxygen("/api/cli/integrations/connect", {
                 method: "POST",
                 body: {
                     integration_id: integrationId,
                     ...(apiKey ? { api_key: apiKey } : {}),
+                    ...(accountId ? { account_id: accountId } : {}),
                 },
             });
         });
@@ -3324,7 +3719,7 @@ export function createProgram() {
         .argument("<integration_id>", "Integration id, such as 'slack'.")
         .option("--json", "Print a JSON envelope.")
         .action(async (integrationId, options) => {
-        await handleAsyncAction("integrations actions", options, async () => {
+        await handleAsyncAction("integrations actions", options, () => {
             const params = new URLSearchParams({ integration_id: integrationId });
             return requestOxygen(`/api/cli/integrations/composio/actions?${params.toString()}`);
         });
@@ -3339,7 +3734,7 @@ export function createProgram() {
         .option("--mode <mode>", "'live' or 'dry_run'. Overridden by --live/--dry-run if provided.")
         .option("--json", "Print a JSON envelope.")
         .action(async (integrationId, actionSlug, options) => {
-        await handleAsyncAction("integrations run", options, async () => {
+        await handleAsyncAction("integrations run", options, () => {
             const args = readOption(options.input)
                 ? parseJsonObject(readOption(options.input))
                 : {};
@@ -3394,7 +3789,7 @@ export function createProgram() {
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("senders get", options, async () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}`));
+        await handleAsyncAction("senders get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}`));
     }))
         .addCommand(new Command("sync")
         .description("Refresh LinkedIn account state (status, profile) from Unipile. Pass --connection-id to sync one account, or omit it to sync all.")
@@ -3416,7 +3811,7 @@ export function createProgram() {
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("senders disconnect", options, async () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/disconnect`, {
+        await handleAsyncAction("senders disconnect", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/disconnect`, {
             method: "POST",
         }));
     }))
@@ -3428,7 +3823,7 @@ export function createProgram() {
         .argument("<id>", "Sender account id, connection id, or Unipile account id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
-        await handleAsyncAction("senders limits get", options, async () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
+        await handleAsyncAction("senders limits get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
     }))
         .addCommand(new Command("set")
         .description("Adjust per-account daily action limits and the daily-reset timezone. Values are clamped to safe maximums (e.g. max 80 invites/day). Send windows (time of day) are set per sequence in the campaign schedule, not per account. <id> accepts a sender account id, connection id, or Unipile account id.")
@@ -3460,10 +3855,11 @@ export function createProgram() {
         });
     }))));
     program.addCommand(new Command("inbox")
-        .description("LinkedIn unified inbox (unibox): scan conversations across all sender accounts, read threads, and reply.")
+        .description("Unified inbox (unibox): LinkedIn conversations and (--channel email) the fleet's email conversations synced from Zapmail Zapbox. Scan, read threads, and reply.")
         .addCommand(new Command("list")
-        .description("List LinkedIn conversations across all connected accounts, newest first.")
-        .option("--account <id>", "Filter to one sender account (sender id, connection id, or Unipile account id).")
+        .description("List conversations across all connected accounts, newest first. --channel email lists the Zapbox-synced email inbox.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
+        .option("--account <id>", "LinkedIn only: filter to one sender account (sender id, connection id, or Unipile account id).")
         .option("--unread", "Only show conversations with unread messages.")
         .option("--search <text>", "Filter by attendee name or last-message text.")
         .option("--include-archived", "Include archived conversations.")
@@ -3472,6 +3868,9 @@ export function createProgram() {
         .action(async (options) => {
         await handleAsyncAction("inbox list", options, () => {
             const params = new URLSearchParams();
+            const channel = readOption(options.channel);
+            if (channel)
+                params.set("channel", channel);
             const account = readOption(options.account);
             if (account)
                 params.set("account", account);
@@ -3490,13 +3889,17 @@ export function createProgram() {
         });
     }))
         .addCommand(new Command("get")
-        .description("Get one conversation with its full message thread. <conversation> accepts a conversation id or Unipile chat id.")
-        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .description("Get one conversation with its full message thread. <conversation> accepts a conversation id, Unipile chat id, or (email) Zapbox thread id.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or Zapbox thread id.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
         .option("--message-limit <n>", "Maximum messages to return (1-500). Defaults to 100.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
         await handleAsyncAction("inbox get", options, () => {
             const params = new URLSearchParams();
+            const channel = readOption(options.channel);
+            if (channel)
+                params.set("channel", channel);
             const messageLimit = readOption(options.messageLimit);
             if (messageLimit)
                 params.set("message_limit", messageLimit);
@@ -3505,19 +3908,24 @@ export function createProgram() {
         });
     }))
         .addCommand(new Command("send")
-        .description("Reply into a LinkedIn conversation. Sends a real LinkedIn message — requires --approved. Without it, returns a preview.")
-        .argument("<conversation>", "Conversation id or Unipile chat id.")
+        .description("Reply into a conversation. --channel email replies from the conversation's own mailbox (Zapbox/native Gmail/Graph, threaded); default replies into the LinkedIn conversation. Sends a real message — requires --approved. Without it, returns a preview.")
+        .argument("<conversation>", "Conversation id, Unipile chat id, or (email) Zapbox thread id.")
         .requiredOption("--text <message>", "Reply text to send.")
+        .option("--channel <channel>", "Inbox channel: linkedin (default) or email.")
         .option("--approved", "Approve and send the message. Without this flag, returns a preview only.")
         .option("--json", "Print a JSON envelope.")
         .action(async (conversation, options) => {
-        await handleAsyncAction("inbox send", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/send`, {
-            method: "POST",
-            body: {
-                text: readOption(options.text),
-                ...(options.approved ? { approved: true } : {}),
-            },
-        }));
+        await handleAsyncAction("inbox send", options, () => {
+            const channel = readOption(options.channel);
+            return requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/send`, {
+                method: "POST",
+                body: {
+                    text: readOption(options.text),
+                    ...(channel ? { channel } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
     }))
         .addCommand(new Command("mark-read")
         .description("Mark a conversation and all its messages as read.")
@@ -3527,15 +3935,40 @@ export function createProgram() {
         await handleAsyncAction("inbox mark-read", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/read`, {
             method: "POST",
         }));
+    }))
+        .addCommand(new Command("analyze")
+        .description("Run the default analysis on an email conversation now: sentiment + interest category + a drafted reply (Oxygen's default model). The worker also does this automatically on inbound mail.")
+        .argument("<conversation>", "Conversation id or Zapbox thread id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox analyze", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/analyze`, {
+            method: "POST",
+            body: { channel: "email" },
+        }));
+    }))
+        .addCommand(new Command("archive")
+        .description("Archive an email conversation (triage it out of the inbox). --unarchive restores it.")
+        .argument("<conversation>", "Conversation id or Zapbox thread id.")
+        .option("--unarchive", "Restore the conversation instead of archiving it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (conversation, options) => {
+        await handleAsyncAction("inbox archive", options, () => requestOxygen(`/api/cli/inbox/${encodeURIComponent(conversation)}/archive`, {
+            method: "POST",
+            body: { channel: "email", archived: !options.unarchive },
+        }));
     }))
         .addCommand(new Command("sync")
         .description("Force a backstop inbox sync from Unipile for all active sender accounts (pulls recent chats + messages into the unibox).")
+        .option("--account <id>", "Force-sync one sender account (sender id, connection id, or Unipile account id).")
         .option("--chat-limit <n>", "Maximum chats to sync per account. Defaults to 30.")
         .option("--message-limit <n>", "Maximum messages to sync per chat. Defaults to 20.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("inbox sync", options, () => {
             const body = {};
+            const account = readOption(options.account);
+            if (account)
+                body.account = account;
             const chatLimit = readOption(options.chatLimit);
             if (chatLimit)
                 body.chat_limit = Number(chatLimit);
@@ -3606,8 +4039,7 @@ export function createProgram() {
             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 definition = readJsonFileValue(resolve(stepsPath), "--steps-file");
             const channels = readCsvOption(options.channels);
             const senders = readCsvOption(options.senders);
             const email = readCampaignEmailBinding(options);
@@ -3649,7 +4081,7 @@ export function createProgram() {
                 body.name = name;
             const stepsPath = readOption(options.stepsFile);
             if (stepsPath) {
-                body.definition = JSON.parse(readFileSync(resolve(stepsPath), "utf8"));
+                body.definition = readJsonFileValue(resolve(stepsPath), "--steps-file");
             }
             const channels = readCsvOption(options.channels);
             if (channels.length > 0)
@@ -3694,7 +4126,7 @@ export function createProgram() {
             const leadsPath = readOption(options.leadsFile);
             if (!leadsPath)
                 throw new Error("--leads-file is required.");
-            const parsed = JSON.parse(readFileSync(resolve(leadsPath), "utf8"));
+            const parsed = readJsonFileValue(resolve(leadsPath), "--leads-file");
             return requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/enroll`, {
                 method: "POST",
                 body: { leads: parsed.leads ?? [] },
@@ -3774,6 +4206,35 @@ export function createProgram() {
         .action(async (sequence, options) => {
         await handleAsyncAction("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`));
     })));
+    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")
+        .description("Send ONE email right now. Without --approved, returns a preview naming the exact mailbox + transport. --from pins a mailbox; otherwise the pool's LRU rotation picks one.")
+        .requiredOption("--to <email>", "Recipient email address (exactly one).")
+        .requiredOption("--subject <text>", "Subject line.")
+        .option("--body <text>", "Plain-text body (sent verbatim, no templating).")
+        .option("--body-file <path>", "Read the body from a file instead of --body.")
+        .option("--from <mailbox>", "Sending mailbox (address or id). Defaults to the pool rotation.")
+        .option("--approved", "Approve and send. Without this flag, returns a preview only.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("email send", options, async () => {
+            const bodyText = readOption(options.body) ?? (options.bodyFile ? readFileSync(resolve(options.bodyFile), "utf8") : undefined);
+            if (!bodyText || !bodyText.trim()) {
+                throw new Error("Provide --body or --body-file.");
+            }
+            return requestOxygen("/api/cli/email/send", {
+                method: "POST",
+                body: {
+                    to: readOption(options.to),
+                    subject: readOption(options.subject),
+                    body: bodyText,
+                    ...(readOption(options.from) ? { from: readOption(options.from) } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                },
+            });
+        });
+    })));
     program.addCommand(new Command("mailboxes")
         .description("Native email sending pool: register/refresh Google/Microsoft mailboxes a campaign rotates over, pause/disable inboxes, and delegate warmup to Instantly (BYOK — Instantly bills your account, 0 Oxygen credits).")
         .addCommand(new Command("list")
@@ -3795,21 +4256,29 @@ export function createProgram() {
         .option("--file <path>", "Path to a JSON file: { \"mailboxes\": [{ email_address, provider, workspace_external_id? }] }.")
         .option("--from <source>", "Import source: 'zapmail' to pull the connected Zapmail workspace's mailboxes.")
         .option("--connection <id>", "Zapmail connection id (--from zapmail). Defaults to the org's active Zapmail connection.")
+        .option("--provider <provider>", "Zapmail pool to pull (--from zapmail): google or microsoft. Zapmail's mailbox list is provider-scoped, so the Microsoft pool is only reachable with --provider microsoft; Microsoft mailboxes get their Entra tenant id stamped on import.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("mailboxes import", options, () => {
             const from = readOption(options.from);
             const filePath = readOption(options.file);
             const connection = readOption(options.connection);
+            const provider = readOption(options.provider);
             if (from === "zapmail") {
                 return requestOxygen("/api/cli/mailboxes", {
                     method: "POST",
-                    body: { source: "zapmail", ...(connection ? { connection_id: connection } : {}) },
+                    body: {
+                        source: "zapmail",
+                        ...(connection ? { connection_id: connection } : {}),
+                        ...(provider ? { service_provider: provider } : {}),
+                    },
                 });
             }
+            if (provider)
+                throw new Error("--provider only applies with --from zapmail (inline files carry a per-mailbox provider).");
             if (!filePath)
                 throw new Error("Provide --file <path> (a { \"mailboxes\": [...] } JSON file) or --from zapmail.");
-            const parsed = JSON.parse(readFileSync(resolve(filePath), "utf8"));
+            const parsed = readJsonFileValue(resolve(filePath), "--file");
             return requestOxygen("/api/cli/mailboxes", {
                 method: "POST",
                 body: { mailboxes: parsed.mailboxes ?? [] },
@@ -3908,68 +4377,177 @@ export function createProgram() {
             return requestOxygen(`/api/cli/mailboxes/warmup/status${suffix ? `?${suffix}` : ""}`);
         });
     }))));
+    program.addCommand(new Command("domains")
+        .description("Cold-email domain management on the org's own Cloudflare account (BYOK): sync zones, inspect age/warmup/DNS health, check availability and pricing, and buy domains. Purchases bill your Cloudflare payment method, never Oxygen credits.")
+        .addCommand(new Command("list")
+        .description("List the org's cached Cloudflare domains with cold-email metadata (age, mailboxes, warmup, sending volume, DNS health). Reads the cache only — run `domains sync` to refresh.")
+        .option("--status <status>", "Filter by zone status: unknown, initializing, pending, active, moved, or deleted.")
+        .option("--registrar <registrar>", "Filter by registrar name.")
+        .option("--q <text>", "Filter by domain substring.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("domains list", options, () => {
+            const params = new URLSearchParams();
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const registrar = readOption(options.registrar);
+            if (registrar)
+                params.set("registrar", registrar);
+            const queryText = readOption(options.q);
+            if (queryText)
+                params.set("q", queryText);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/domains${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("sync")
+        .description("Refresh the domain cache from Cloudflare: zone pages, registrar metadata, RDAP age backfill, and DNS health. Partial (paginated) syncs auto-continue until complete.")
+        .option("--full", "Restart the sweep from the first zone page instead of resuming the cursor.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("domains sync", options, () => runDomainsSync(options));
+    }))
+        .addCommand(new Command("get")
+        .description("Get one domain's full detail: zone state, age with provenance, mailboxes, sending volume, and the last DNS health check.")
+        .argument("<domain>", "Domain name, such as acme.com.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (domain, options) => {
+        await handleAsyncAction("domains get", options, () => requestOxygen(`/api/cli/domains/${encodeURIComponent(domain)}`));
+    }))
+        .addCommand(new Command("dns")
+        .description("Run a live read-only DNS health check (SPF, DKIM, DMARC, MX) against the domain's Cloudflare zone and persist the result.")
+        .argument("<domain>", "Domain name, such as acme.com.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (domain, options) => {
+        await handleAsyncAction("domains dns", options, () => requestOxygen(`/api/cli/domains/${encodeURIComponent(domain)}/dns`));
+    }))
+        .addCommand(new Command("search")
+        .description("Search Cloudflare Registrar for available domains with registration/renewal pricing. Free — nothing is purchased.")
+        .argument("<query>", "Search text, such as a brand or keyword.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (query, options) => {
+        await handleAsyncAction("domains search", options, () => {
+            const params = new URLSearchParams({ q: query });
+            return requestOxygen(`/api/cli/domains/search?${params.toString()}`);
+        });
+    }))
+        .addCommand(new Command("check")
+        .description("Check availability and pricing for up to 20 specific domains via Cloudflare Registrar. Free — nothing is purchased.")
+        .argument("<domains...>", "Domain names to check (max 20).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (domains, options) => {
+        await handleAsyncAction("domains check", options, () => {
+            if (domains.length > DOMAINS_CHECK_MAX_DOMAINS) {
+                throw new Error(`Cloudflare checks at most ${DOMAINS_CHECK_MAX_DOMAINS} domains per call (got ${domains.length}). Split the list and re-run.`);
+            }
+            return requestOxygen("/api/cli/domains/check", {
+                method: "POST",
+                body: { domains },
+            });
+        });
+    }))
+        .addCommand(new Command("buy")
+        .description("Buy domains through Cloudflare Registrar. REAL MONEY, NON-REFUNDABLE — the preview determines billing: BYOK orgs (connected Cloudflare token) bill their own Cloudflare payment method (0 Oxygen credits); managed orgs (no connected token) bill Oxygen credits at a markup on the shared Oxygen Cloudflare account. The preview's `billing` note states which applies. Without --approved, returns a priced preview plus a quote_id; re-run with --approved --quote <id> to execute.")
+        .argument("<domains...>", "Domain names to buy.")
+        .option("--approved", "Execute the purchase. Without this flag, returns a preview only.")
+        .option("--quote <id>", "Quote id from the preview (required with --approved).")
+        .option("--accept-premium", "Acknowledge premium-tier pricing for premium domains.")
+        .option("--auto-renew", "Enable auto-renew on the new registrations.")
+        .option("--no-privacy", "Disable WHOIS privacy/redaction on the new registrations.")
+        .option("--wait", "After an approved purchase, poll each pending registration to a terminal state (up to 10 minutes per domain).")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (domains, options) => {
+        await handleAsyncAction("domains buy", options, () => runDomainsBuy(domains, options));
+    }))
+        .addCommand(new Command("registrations")
+        .description("List the org's domain purchase ledger: every registration attempt with status and price snapshot.")
+        .option("--status <status>", "Filter by ledger status: submitting, in_progress, succeeded, failed, action_required, or blocked.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("domains registrations", options, () => {
+            const params = new URLSearchParams();
+            const status = readOption(options.status);
+            if (status)
+                params.set("status", status);
+            const suffix = params.toString();
+            return requestOxygen(`/api/cli/domains/registrations${suffix ? `?${suffix}` : ""}`);
+        });
+    }))
+        .addCommand(new Command("registration-status")
+        .description("Get one domain registration's ledger state (the server performs a gated live poll when due — safe to call repeatedly). Pass --wait to poll until it settles.")
+        .argument("<domain>", "Domain name from a previous `domains buy`.")
+        .option("--wait", "Poll every 10s (up to 10 minutes) until the registration reaches a terminal state.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (domain, options) => {
+        await handleAsyncAction("domains registration-status", options, () => {
+            if (options.wait)
+                return waitForDomainRegistration(domain);
+            return requestOxygen(`/api/cli/domains/registrations/${encodeURIComponent(domain)}`);
+        });
+    })));
     program
         .command("workflows")
         .description("Durable workflow automation commands.")
         .addCommand(new Command("templates")
-        .description("Discover and run reusable Oxygen workflow templates.")
+        .description("Deprecated aliases for `oxygen blueprints` — these route through the canonical blueprint surface (built-in seed templates plus this workspace's saved blueprints).")
         .addCommand(new Command("search")
-        .description("Search reusable workflow templates.")
+        .description("Deprecated alias for `oxygen blueprints list`. Searches Oxygen blueprints (seed templates plus saved blueprints).")
         .argument("[query]", "Search text.")
-        .option("--tag <tag>", "Filter by template tag.")
+        .option("--tag <tag>", "Filter by blueprint tag.")
         .option("--json", "Print a JSON envelope.")
         .action(async (query, options) => {
-        await handleAsyncAction("workflows templates search", options, async () => {
+        await handleAsyncAction("workflows templates search", options, () => {
             const params = new URLSearchParams();
             params.set("query", query ?? "");
             if (readOption(options.tag))
                 params.set("tag", readOption(options.tag) ?? "");
-            return requestOxygen(`/api/cli/workflows/templates?${params.toString()}`);
+            return requestOxygen(`/api/cli/blueprints?${params.toString()}`);
         });
     }))
         .addCommand(new Command("describe")
-        .description("Describe one workflow template.")
-        .argument("<template_id>", "Workflow template id.")
+        .description("Deprecated alias for `oxygen blueprints describe`.")
+        .argument("<template_id>", "Blueprint slug (formerly workflow template id).")
         .option("--json", "Print a JSON envelope.")
         .action(async (templateId, options) => {
-        await handleAsyncAction("workflows templates describe", options, async () => requestOxygen("/api/cli/workflows/templates/describe", {
+        await handleAsyncAction("workflows templates describe", options, () => requestOxygen("/api/cli/blueprints/get", {
             method: "POST",
-            body: { template_id: templateId },
+            body: { slug: templateId },
         }));
     }))
         .addCommand(new Command("preflight")
-        .description("Validate workflow template inputs and preview effects without running it.")
-        .argument("<template_id>", "Workflow template id.")
-        .requiredOption("--input-json <json>", "Template input as a JSON object.")
-        .option("--mode <mode>", "Execution mode: smoke_test, dry_run, or live.")
-        .option("--max-credits <credits>", "Credit ceiling for paid live work.")
+        .description("Deprecated alias for `oxygen blueprints preflight`. Validates inputs and previews effects without running.")
+        .argument("<template_id>", "Blueprint slug (formerly workflow template id).")
+        .requiredOption("--input-json <json>", "Blueprint input as a JSON object.")
+        .option("--mode <mode>", "Deprecated and ignored: blueprints validate without a run mode.")
+        .option("--max-credits <credits>", "Credit ceiling; folded into inputs.max_credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (templateId, options) => {
-        await handleAsyncAction("workflows templates preflight", options, async () => requestOxygen("/api/cli/workflows/templates/preflight", {
+        await handleAsyncAction("workflows templates preflight", options, () => requestOxygen("/api/cli/blueprints/preflight", {
             method: "POST",
-            body: workflowTemplateActionBody(templateId, options),
+            body: workflowTemplateBlueprintBody(templateId, options),
         }));
     }))
         .addCommand(new Command("apply")
-        .description("Create or update a disabled workflow from a template.")
-        .argument("<template_id>", "Workflow template id.")
-        .requiredOption("--input-json <json>", "Template input as a JSON object.")
-        .option("--workflow-id <workflow_id>", "Workflow id to create or update.")
-        .option("--workflow-name <workflow_name>", "Workflow display name.")
-        .option("--mode <mode>", "Mode used for preflight validation.")
-        .option("--max-credits <credits>", "Credit ceiling to store in template defaults.")
+        .description("Deprecated alias for `oxygen blueprints apply`. Creates a disabled workflow (plus its tables, columns, and prompts) from a blueprint.")
+        .argument("<template_id>", "Blueprint slug (formerly workflow template id).")
+        .requiredOption("--input-json <json>", "Blueprint input as a JSON object.")
+        .option("--workflow-id <workflow_id>", "Override the resulting workflow id.")
+        .option("--workflow-name <workflow_name>", "Override the resulting workflow name.")
+        .option("--mode <mode>", "Deprecated and ignored: the workflow is created disabled.")
+        .option("--max-credits <credits>", "Credit ceiling; folded into inputs.max_credits.")
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (templateId, options) => {
-        await handleAsyncAction("workflows templates apply", options, async () => prepareWorkflowCliOutput(await requestOxygen("/api/cli/workflows/templates/apply", {
+        await handleAsyncAction("workflows templates apply", options, async () => prepareWorkflowCliOutput(await requestOxygen("/api/cli/blueprints/apply", {
             method: "POST",
-            body: workflowTemplateActionBody(templateId, options),
+            body: workflowTemplateBlueprintBody(templateId, options, true),
         }), options));
     }))
         .addCommand(new Command("run")
-        .description("Apply a template as an active workflow and enqueue one run.")
-        .argument("<template_id>", "Workflow template id.")
-        .requiredOption("--input-json <json>", "Template input as a JSON object.")
+        .description("Removed: returns a typed 410 deprecation. Use `oxygen blueprints apply <slug>` then `oxygen workflows call <workflow>`.")
+        .argument("<template_id>", "Blueprint slug (formerly workflow template id).")
+        .requiredOption("--input-json <json>", "Blueprint input as a JSON object.")
         .requiredOption("--mode <mode>", "Execution mode: smoke_test, dry_run, or live.")
         .option("--workflow-id <workflow_id>", "Workflow id to create or update.")
         .option("--workflow-name <workflow_name>", "Workflow display name.")
@@ -3988,7 +4566,7 @@ export function createProgram() {
         .option("--subject <subject>", "Schema subject: all, apply, call, event, trigger, or manifest.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("workflows schema", options, async () => requestOxygen(`/api/cli/workflows/schema?subject=${encodeURIComponent(options.subject ?? "all")}`));
+        await handleAsyncAction("workflows schema", options, () => requestOxygen(`/api/cli/workflows/schema?subject=${encodeURIComponent(options.subject ?? "all")}`));
     }))
         .addCommand(new Command("lint")
         .description("Compile and lint a workflow file without saving it.")
@@ -4021,7 +4599,7 @@ export function createProgram() {
         .description("List workflow automations.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("workflows list", options, async () => requestOxygen("/api/cli/workflows"));
+        await handleAsyncAction("workflows list", options, () => requestOxygen("/api/cli/workflows"));
     }))
         .addCommand(new Command("get")
         .description("Get one workflow automation.")
@@ -4064,9 +4642,12 @@ export function createProgram() {
         .option("--input-json <json>", "Workflow input object. Defaults to {}.")
         .requiredOption("--mode <mode>", "Execution mode: live, dry-run, or smoke-test.")
         .option("--idempotency-key <key>", "Optional idempotency key.")
+        .option("--max-credits <n>", "Required credit ceiling for live calls.")
+        .option("--approved", "Required for live calls after inspecting a dry run.")
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (workflowArg, options) => {
+        const maxCredits = readPositiveNumber(options.maxCredits);
         await handleAsyncAction("workflows call", options, async () => prepareWorkflowCliOutput(await requestOxygen("/api/cli/workflows/call", {
             method: "POST",
             body: {
@@ -4076,6 +4657,8 @@ export function createProgram() {
                 input: options.inputJson ? parseJsonObject(options.inputJson) : {},
                 ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
                 ...(readOption(options.idempotencyKey) ? { idempotency_key: readOption(options.idempotencyKey) } : {}),
+                ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                ...(options.approved ? { approved: true } : {}),
             },
         }), options));
     }))
@@ -4171,14 +4754,14 @@ export function createProgram() {
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("workflows tail", options, async () => prepareWorkflowCliOutput(await tailWorkflowRun(runId, options), options));
+        await handleAsyncAction("workflows tail", options, async () => prepareWorkflowCliOutput(await waitForWorkflowRun(runId, options), options));
     }))
         .addCommand(new Command("cancel")
         .description("Cancel a queued or running workflow run.")
         .argument("<run_id>", "Workflow run UUID.")
         .option("--json", "Print a JSON envelope.")
         .action(async (runId, options) => {
-        await handleAsyncAction("workflows cancel", options, async () => requestOxygen("/api/cli/workflows/cancel", {
+        await handleAsyncAction("workflows cancel", options, () => requestOxygen("/api/cli/workflows/cancel", {
             method: "POST",
             body: { run_id: runId },
         }));
@@ -4188,7 +4771,7 @@ export function createProgram() {
         .argument("<workflow>", "Workflow id, slug, or name.")
         .option("--json", "Print a JSON envelope.")
         .action(async (workflow, options) => {
-        await handleAsyncAction("workflows enable", options, async () => requestOxygen("/api/cli/workflows/enable", {
+        await handleAsyncAction("workflows enable", options, () => requestOxygen("/api/cli/workflows/enable", {
             method: "POST",
             body: { workflow },
         }));
@@ -4198,7 +4781,7 @@ export function createProgram() {
         .argument("<workflow>", "Workflow id, slug, or name.")
         .option("--json", "Print a JSON envelope.")
         .action(async (workflow, options) => {
-        await handleAsyncAction("workflows disable", options, async () => requestOxygen("/api/cli/workflows/disable", {
+        await handleAsyncAction("workflows disable", options, () => requestOxygen("/api/cli/workflows/disable", {
             method: "POST",
             body: { workflow },
         }));
@@ -4211,14 +4794,14 @@ export function createProgram() {
         .option("--api-url <url>", "Oxygen app URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("skills list", options, async () => listAgentSkills(options));
+        await handleAsyncAction("skills list", options, () => listAgentSkills(options));
     }))
         .addCommand(new Command("doctor")
         .description("Check Oxygen skill index reachability and local installer prerequisites.")
         .option("--api-url <url>", "Oxygen app URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("skills doctor", options, async () => doctorAgentSkills(options));
+        await handleAsyncAction("skills doctor", options, () => doctorAgentSkills(options));
     }))
         .addCommand(new Command("install")
         .description("Install Oxygen agent skills into local agent skill directories.")
@@ -4229,6 +4812,7 @@ export function createProgram() {
         .option("--copy", "Copy skill files instead of symlinking when supported by npx skills. Default on Windows, where symlinks need Developer Mode or admin.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
+        // skipcq: JS-0116 — async Promise-wraps the synchronous installAgentSkills helper to satisfy handleAsyncAction's Promise<unknown> action
         await handleAsyncAction("skills install", options, async () => installAgentSkills(options));
     }));
     return program;
@@ -4349,8 +4933,8 @@ function referencesRecipeSdk(source) {
 }
 // Escape Next static analysis (the CLI is bundled by tsc, but mirror the
 // worker's escape so both load identically).
+// skipcq: JS-R1003 — intentional dynamic-import escape mirrored from the worker; not arbitrary code execution
 const dynamicRecipeImport = new Function("specifier", "return import(specifier);");
-// skipcq: JS-R1003
 async function importRecipeModule(specifier) {
     try {
         return await dynamicRecipeImport(specifier);
@@ -4497,66 +5081,64 @@ export function toolStep(input) {
 }
 `;
 }
-async function tailWorkflowRun(// skipcq: JS-R1005 -- CLI tailer coordinates polling, status transitions, and final output formatting.
-runId, options) {
-    const timeoutSeconds = readPositiveInt(options.timeoutSeconds)
-        ?? WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS;
-    const intervalSeconds = readPositiveInt(options.intervalSeconds)
-        ?? WORKFLOW_TAIL_DEFAULT_INTERVAL_SECONDS;
-    const startedAt = Date.now();
-    const deadline = startedAt + timeoutSeconds * 1000;
-    let polls = 0;
-    while (true) {
-        polls += 1;
-        const latest = await requestOxygen("/api/cli/workflows/run", {
-            method: "POST",
-            body: { run_id: runId },
-        });
-        const run = isRecord(latest.run) ? latest.run : latest;
-        const status = readRecordString(run, "status");
-        if (isTerminalWorkflowRunStatus(status)) {
-            const workflowUrl = readRecordString(latest, "workflowUrl");
-            const runUrl = readRecordString(latest, "runUrl");
-            const webUrl = readRecordString(latest, "web_url");
-            const deepLink = readRecordString(latest, "deepLink");
+// The workflow tailer is the one bespoke wait surface: it POSTs (rather than
+// GETs a run by id), reads the run nested under the response envelope, and
+// carries the workflow/run/deep-link URLs from that envelope into its terminal
+// output. The shared waitForCliRun loop drives polling; this config injects the
+// workflow-specific fetch, terminal shape, and queued-no-worker timeout hint.
+function waitForWorkflowRun(runId, options) {
+    // Captured per poll so shapeTerminal can read the envelope-level URLs while
+    // fetchRun returns the nested run (where the status lives).
+    let latestEnvelope = {};
+    return waitForCliRun({
+        runId,
+        requestedTimeoutSeconds: options.timeoutSeconds,
+        requestedIntervalSeconds: options.intervalSeconds,
+        defaultTimeoutSeconds: WORKFLOW_TAIL_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: WORKFLOW_TAIL_DEFAULT_INTERVAL_SECONDS,
+        fetchRun: async () => {
+            latestEnvelope = await requestOxygen("/api/cli/workflows/run", {
+                method: "POST",
+                body: { run_id: runId },
+            });
+            return isRecord(latestEnvelope.run) ? latestEnvelope.run : latestEnvelope;
+        },
+        isTerminal: isTerminalWorkflowRunStatus,
+        shapeTerminal: (run, status, polls, elapsedMs) => {
+            const workflowUrl = readRecordString(latestEnvelope, "workflowUrl");
+            const runUrl = readRecordString(latestEnvelope, "runUrl");
+            const webUrl = readRecordString(latestEnvelope, "web_url");
+            const deepLink = readRecordString(latestEnvelope, "deepLink");
             return {
                 run,
                 workflowRunId: readRecordString(run, "id") ?? runId,
                 status,
                 terminal: true,
                 polls,
-                elapsedMs: Date.now() - startedAt,
+                elapsedMs,
                 ...(workflowUrl ? { workflowUrl } : {}),
                 ...(runUrl ? { runUrl } : {}),
                 ...(webUrl ? { web_url: webUrl } : {}),
                 ...(deepLink ? { deepLink } : {}),
             };
-        }
-        const remainingMs = deadline - Date.now();
-        if (remainingMs <= 0) {
-            const worker = isRecord(run.worker) ? run.worker : null;
+        },
+        timeoutCode: "workflow_tail_timeout",
+        timeoutMessage: "Timed out waiting for workflow run to finish.",
+        timeoutDetailIdKey: "workflow_run_id",
+        timeoutExtraDetails: (latestRun, status) => {
+            const worker = latestRun && isRecord(latestRun.worker) ? latestRun.worker : null;
             const queuedWithoutWorker = status === "queued"
                 && worker !== null
                 && worker.active === null
                 && worker.lastClaim === null;
-            throw new OxygenError("workflow_tail_timeout", "Timed out waiting for workflow run to finish.", {
-                details: {
-                    workflow_run_id: runId,
-                    status: status ?? null,
-                    timeout_seconds: timeoutSeconds,
-                    polls,
-                    ...(queuedWithoutWorker
-                        ? {
-                            worker_status: "queued_no_worker",
-                            guidance: "No worker has claimed this workflow run. Check `oxygen worker queue-stats --json` for Postgres-backed worker queue health.",
-                        }
-                        : {}),
-                },
-                exitCode: 1,
-            });
-        }
-        await sleep(Math.min(intervalSeconds * 1000, remainingMs));
-    }
+            return queuedWithoutWorker
+                ? {
+                    worker_status: "queued_no_worker",
+                    guidance: "No worker has claimed this workflow run. Check `oxygen worker queue-stats --json` for Postgres-backed worker queue health.",
+                }
+                : {};
+        },
+    });
 }
 function workflowTemplateActionBody(templateId, options) {
     const inputJson = readOption(options.inputJson);
@@ -4571,6 +5153,28 @@ function workflowTemplateActionBody(templateId, options) {
         ...(options.approved ? { approved: true } : {}),
     };
 }
+// OXY-481: the deprecated `workflows templates {search,describe,preflight,apply}`
+// commands route through the canonical blueprint API. Map the legacy arg names
+// (template_id -> slug, --input-json -> inputs) and fold the old top-level
+// max_credits into inputs.max_credits, where seed blueprints read their cap.
+function workflowTemplateBlueprintBody(templateId, options, includeWorkflowOverrides = false) {
+    const inputJson = readOption(options.inputJson);
+    const inputs = inputJson ? parseJsonObject(inputJson) : {};
+    const maxCredits = readPositiveNumber(options.maxCredits);
+    if (maxCredits !== undefined) {
+        inputs.max_credits = maxCredits;
+    }
+    const body = { slug: templateId, inputs };
+    if (includeWorkflowOverrides) {
+        const workflowId = readOption(options.workflowId);
+        if (workflowId)
+            body.workflow_id = workflowId;
+        const workflowName = readOption(options.workflowName);
+        if (workflowName)
+            body.workflow_name = workflowName;
+    }
+    return body;
+}
 function prepareWorkflowCliOutput(value, options) {
     const normalized = normalizeWorkflowRunErrors(value);
     return (options.includeBundle ? normalized : stripWorkflowBundles(normalized));
@@ -4727,6 +5331,34 @@ function readTableRunSelection(options) {
         exitCode: 1,
     });
 }
+function applyAiColumnConfig(definition, options) {
+    const model = readOption(options.model);
+    if (model)
+        definition.model = model;
+    const reasoningLevel = readOption(options.reasoningLevel);
+    if (reasoningLevel)
+        definition.reasoningLevel = reasoningLevel;
+    const runCondition = readOption(options.runCondition);
+    if (runCondition) {
+        definition.runCondition = {
+            type: "formula",
+            expression: runCondition,
+            referencedColumns: readCsvOption(options.runConditionColumns),
+        };
+    }
+    const outputSchemaJson = readOption(options.outputSchemaJson);
+    const outputSchemaFile = readOption(options.outputSchemaFile);
+    if (outputSchemaJson && outputSchemaFile) {
+        throw new OxygenError("invalid_request", "Pass either --output-schema-json or --output-schema-file, not both.", { exitCode: 1 });
+    }
+    if (outputSchemaJson) {
+        definition.outputSchema = parseJsonValue(outputSchemaJson, "--output-schema-json");
+    }
+    else if (outputSchemaFile) {
+        definition.outputSchema = readJsonFileValue(resolve(outputSchemaFile), "--output-schema-file");
+    }
+    return definition;
+}
 function tableRunsListPath(options) {
     const table = readOption(options.table);
     if (!table) {
@@ -4926,7 +5558,7 @@ function readCompanySearchFilters(options) {
     const fundingStages = readCsvOption(options.fundingStages);
     if (fundingStages.length > 0)
         filters.funding = { stages: fundingStages };
-    const technologies = readIncludeExclude(options.technologies, undefined);
+    const technologies = readIncludeExclude(options.technologies);
     if (technologies)
         filters.technologies = technologies;
     const revenue = readRangeOption(options.revenue, "--revenue");
@@ -5015,6 +5647,22 @@ function assertNotCompanySearchKind(kind) {
         });
     }
 }
+// People search has moved to the dedicated people-search surface. The CLI rejects
+// `oxygen search plan --kind people_search` client-side so a stale agent gets a typed,
+// self-correcting error instead of an opaque server 400. Message mirrors
+// PEOPLE_SEARCH_MOVED_MESSAGE in @oxygen/tools (CLI does not import that package).
+const PEOPLE_SEARCH_MOVED_MESSAGE = "People search is handled by the dedicated people-search surface. Use: oxygen people search plan --prompt \"<goal>\" (CLI) or oxygen_people_search_plan (MCP).";
+function assertNotPeopleSearchKind(kind) {
+    if (readOption(kind) === "people_search") {
+        throw new OxygenError("use_people_search", PEOPLE_SEARCH_MOVED_MESSAGE, {
+            details: {
+                equivalent_cli: "oxygen people search plan --prompt <goal>",
+                equivalent_mcp: "oxygen_people_search_plan",
+            },
+            exitCode: 1,
+        });
+    }
+}
 function readCompanySearchPlanJson(value) {
     const parsed = parseJsonObject(readFileIfPresent(value));
     const data = parsed.data;
@@ -5030,7 +5678,8 @@ function readPeopleSearchPlanBody(options) {
         ...(targetCount !== undefined ? { target_count: targetCount } : {}),
         ...(options.sourceIntent ? { source_intent: options.sourceIntent } : {}),
         ...(filters ? { filters } : {}),
-        ...(options.estimate ? { estimate: true } : {}),
+        // Free sizing is on by default; only --no-estimate (options.estimate === false) opts out.
+        estimate: options.estimate !== false,
         ...(options.materializePreview ? { materialize_preview: true } : {}),
     };
 }
@@ -5057,7 +5706,8 @@ function readPeopleSearchRunBody(options) {
         ...(targetCount !== undefined ? { target_count: targetCount } : {}),
         ...(options.sourceIntent ? { source_intent: options.sourceIntent } : {}),
         ...(filters ? { filters } : {}),
-        ...(prompt && options.estimate ? { estimate: true } : {}),
+        // Free sizing is on by default when planning from a prompt; --no-estimate opts out.
+        ...(prompt ? { estimate: options.estimate !== false } : {}),
         ...(options.approved ? { approved: true } : {}),
     };
 }
@@ -5210,6 +5860,26 @@ function readFilterJsonOption(value) {
     }
     return filters;
 }
+function readFilterTreeJsonOption(value) {
+    const raw = readOption(value);
+    if (!raw)
+        return undefined;
+    return parseJsonObject(raw);
+}
+function readSortJsonOption(value) {
+    const raw = readOption(value);
+    if (!raw)
+        return undefined;
+    const parsed = parseJsonArray(raw);
+    if (parsed.length === 0)
+        return undefined;
+    if (parsed.some((entry) => !entry || typeof entry !== "object" || Array.isArray(entry))) {
+        throw new OxygenError("invalid_sort", "--sort-json must be an array of sort-rule objects.", {
+            exitCode: 1,
+        });
+    }
+    return parsed;
+}
 function parseStringArray(value) {
     const parsed = parseJsonArray(value);
     const labels = parsed
@@ -5236,6 +5906,7 @@ function normalizeSessionStepStatus(value) {
         exitCode: 1,
     });
 }
+// skipcq: JS-R1005 — intentional branching over file format, create/upsert, and sync/background import modes
 async function importRows(table, options) {
     const format = normalizeRowsFormat(options.format, inferRowsFileFormat(options.file));
     const parsedRows = await readRowsFile(options.file, format, options.sheet);
@@ -5640,118 +6311,249 @@ function emitQueueWaitStderrNote(queueWait) {
     if (note)
         process.stderr.write(`note: ${note}\n`);
 }
-async function waitForTableIngestionRun(runId, options) {
-    const timeoutSeconds = readPositiveInt(options.timeoutSeconds)
-        ?? TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS;
-    const intervalSeconds = readPositiveInt(options.intervalSeconds)
-        ?? TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS;
-    const startedAt = Date.now();
-    const deadline = startedAt + timeoutSeconds * 1000;
-    let polls = 0;
-    while (true) {
-        polls += 1;
-        const latestRun = await requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}`);
-        const status = readRecordString(latestRun, "status");
-        if (isTerminalTableIngestionStatus(status)) {
+function buildGetSurfaceRunWaitConfig(params) {
+    return {
+        runId: params.runId,
+        requestedTimeoutSeconds: params.requestedTimeoutSeconds,
+        requestedIntervalSeconds: params.requestedIntervalSeconds,
+        defaultTimeoutSeconds: params.defaultTimeoutSeconds,
+        defaultIntervalSeconds: params.defaultIntervalSeconds,
+        fetchRun: () => requestOxygen(`${params.endpoint}/${encodeURIComponent(params.runId)}`),
+        isTerminal: params.isTerminal,
+        shapeTerminal: (run, status, polls, elapsedMs) => {
+            const webUrl = readRecordString(run, "web_url");
             return {
-                ingestionRun: latestRun,
-                ingestionRunId: readRecordString(latestRun, "id") ?? runId,
+                [params.runKey]: run,
+                [params.runIdKey]: readRecordString(run, "id") ?? params.runId,
                 status,
                 terminal: true,
                 polls,
-                elapsedMs: Date.now() - startedAt,
-                ...(readRecordString(latestRun, "web_url") ? { web_url: readRecordString(latestRun, "web_url") } : {}),
+                elapsedMs,
+                ...(webUrl ? { web_url: webUrl } : {}),
             };
+        },
+        timeoutCode: params.timeoutCode,
+        timeoutMessage: params.timeoutMessage,
+        timeoutDetailIdKey: params.timeoutDetailIdKey,
+    };
+}
+function waitForTableIngestionRun(runId, options) {
+    return waitForCliRun(buildGetSurfaceRunWaitConfig({
+        runId,
+        endpoint: "/api/cli/table-ingestion-runs",
+        requestedTimeoutSeconds: options.timeoutSeconds,
+        requestedIntervalSeconds: options.intervalSeconds,
+        defaultTimeoutSeconds: TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS,
+        isTerminal: isTerminalTableIngestionStatus,
+        runKey: "ingestionRun",
+        runIdKey: "ingestionRunId",
+        timeoutCode: "table_ingestion_wait_timeout",
+        timeoutMessage: "Timed out waiting for table ingestion run to finish.",
+        timeoutDetailIdKey: "ingestion_run_id",
+    }));
+}
+function waitForSearchRun(runId, options) {
+    return waitForCliRun(buildGetSurfaceRunWaitConfig({
+        runId,
+        endpoint: "/api/cli/search/runs",
+        requestedTimeoutSeconds: options.timeoutSeconds,
+        requestedIntervalSeconds: options.intervalSeconds,
+        // Search intentionally reuses the table-ingestion defaults and terminal
+        // predicate; the status set is identical (a naming-drift smell, not a bug).
+        defaultTimeoutSeconds: TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS,
+        isTerminal: isTerminalTableIngestionStatus,
+        runKey: "searchRun",
+        runIdKey: "searchRunId",
+        timeoutCode: "search_run_wait_timeout",
+        timeoutMessage: "Timed out waiting for search run to finish.",
+        timeoutDetailIdKey: "search_run_id",
+    }));
+}
+function waitForTableActionRun(runId, options) {
+    return waitForCliRun(buildGetSurfaceRunWaitConfig({
+        runId,
+        endpoint: "/api/cli/table-action-runs",
+        requestedTimeoutSeconds: options.timeoutSeconds,
+        requestedIntervalSeconds: options.intervalSeconds,
+        defaultTimeoutSeconds: TABLE_ACTION_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: TABLE_ACTION_RUN_WAIT_DEFAULT_INTERVAL_SECONDS,
+        isTerminal: isTerminalTableActionRunStatus,
+        runKey: "actionRun",
+        runIdKey: "actionRunId",
+        timeoutCode: "table_action_run_wait_timeout",
+        timeoutMessage: "Timed out waiting for table action run to finish.",
+        timeoutDetailIdKey: "action_run_id",
+    }));
+}
+// Domain sync is paginated under the server's Cloudflare request budget; the
+// CLI re-POSTs the same body while the server reports a partial sweep with a
+// next page, then prints one aggregated summary.
+async function runDomainsSync(options) {
+    const body = options.full ? { full: true } : {};
+    let totalSynced = 0;
+    let totalPagesFetched = 0;
+    let totalRdapResolved = 0;
+    let totalDnsChecked = 0;
+    let sawRdapResolved = false;
+    let sawDnsChecked = false;
+    let requestCount = 0;
+    for (;;) {
+        requestCount += 1;
+        const latest = await requestOxygen("/api/cli/domains/sync", {
+            method: "POST",
+            body,
+        });
+        // `full` means "restart from page 1" server-side; only the first request may
+        // carry it. Continuations must drop it so the server advances the saved
+        // cursor instead of re-sweeping the first pages every iteration.
+        delete body.full;
+        totalSynced += readCount(latest.synced);
+        totalPagesFetched += readCount(latest.pages_fetched);
+        if (typeof latest.rdap_resolved === "number") {
+            sawRdapResolved = true;
+            totalRdapResolved += readCount(latest.rdap_resolved);
         }
-        const remainingMs = deadline - Date.now();
-        if (remainingMs <= 0) {
-            throw new OxygenError("table_ingestion_wait_timeout", "Timed out waiting for table ingestion run to finish.", {
-                details: {
-                    ingestion_run_id: runId,
-                    status: status ?? null,
-                    timeout_seconds: timeoutSeconds,
-                    polls,
-                },
-                exitCode: 1,
-            });
+        if (typeof latest.dns_checked === "number") {
+            sawDnsChecked = true;
+            totalDnsChecked += readCount(latest.dns_checked);
         }
-        await sleep(Math.min(intervalSeconds * 1000, remainingMs));
-    }
-}
-async function waitForSearchRun(runId, options) {
-    const timeoutSeconds = readPositiveInt(options.timeoutSeconds)
-        ?? TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS;
-    const intervalSeconds = readPositiveInt(options.intervalSeconds)
-        ?? TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS;
-    const startedAt = Date.now();
-    const deadline = startedAt + timeoutSeconds * 1000;
-    let polls = 0;
-    while (true) {
-        polls += 1;
-        const latestRun = await requestOxygen(`/api/cli/search/runs/${encodeURIComponent(runId)}`);
-        const status = readRecordString(latestRun, "status");
-        if (isTerminalTableIngestionStatus(status)) {
+        const hasNextPage = latest.next_page !== undefined && latest.next_page !== null;
+        const shouldContinue = latest.partial === true
+            && hasNextPage
+            && requestCount <= DOMAINS_SYNC_MAX_CONTINUATIONS;
+        if (!shouldContinue) {
             return {
-                searchRun: latestRun,
-                searchRunId: readRecordString(latestRun, "id") ?? runId,
-                status,
-                terminal: true,
-                polls,
-                elapsedMs: Date.now() - startedAt,
-                ...(readRecordString(latestRun, "web_url") ? { web_url: readRecordString(latestRun, "web_url") } : {}),
+                ...latest,
+                synced: totalSynced,
+                pages_fetched: totalPagesFetched,
+                ...(sawRdapResolved ? { rdap_resolved: totalRdapResolved } : {}),
+                ...(sawDnsChecked ? { dns_checked: totalDnsChecked } : {}),
+                requests: requestCount,
             };
         }
-        const remainingMs = deadline - Date.now();
-        if (remainingMs <= 0) {
-            throw new OxygenError("search_run_wait_timeout", "Timed out waiting for search run to finish.", {
-                details: {
-                    search_run_id: runId,
-                    status: status ?? null,
-                    timeout_seconds: timeoutSeconds,
-                    polls,
-                },
-                exitCode: 1,
-            });
-        }
-        await sleep(Math.min(intervalSeconds * 1000, remainingMs));
+        // A 429 mid-sync keeps completed pages and reports a pushback window.
+        const retryAfterSeconds = readCount(latest.retry_after_seconds);
+        if (retryAfterSeconds > 0)
+            await sleep(retryAfterSeconds * 1000);
+    }
+}
+async function runDomainsBuy(domains, options) {
+    const quoteId = readOption(options.quote);
+    if (options.approved && !quoteId) {
+        throw new Error("--quote <id> is required with --approved. Run the same command without --approved first to get the preview and its quote_id.");
     }
+    const data = await requestOxygen("/api/cli/domains/buy", {
+        method: "POST",
+        body: {
+            domains,
+            ...(options.autoRenew ? { auto_renew: true } : {}),
+            ...(options.privacy === false ? { privacy: false } : {}),
+            ...(options.approved ? { approved: true, quote_id: quoteId } : {}),
+            ...(options.acceptPremium ? { accept_premium_pricing: true } : {}),
+        },
+    });
+    if (!options.approved) {
+        const previewQuoteId = readRecordString(data, "quote_id");
+        return previewQuoteId
+            ? { ...data, rerun_command: domainsBuyRerunCommand(domains, previewQuoteId, options, data) }
+            : data;
+    }
+    if (!options.wait)
+        return data;
+    const pendingDomains = Array.isArray(data.results)
+        ? data.results
+            .filter((entry) => {
+            const status = readRecordString(entry, "status");
+            return status === "submitting" || status === "in_progress";
+        })
+            .map((entry) => readRecordString(entry, "domain"))
+            .filter((entry) => entry !== null)
+        : [];
+    if (pendingDomains.length === 0)
+        return data;
+    const waitResults = [];
+    for (const domain of pendingDomains) {
+        waitResults.push(await waitForDomainRegistration(domain));
+    }
+    return { ...data, wait: { waited: pendingDomains.length, results: waitResults } };
+}
+function domainsBuyRerunCommand(domains, quoteId, options, data) {
+    // The buy preview returns items and requires_accept_premium_pricing at the
+    // TOP level of data (there is no preview wrapper); reading data.preview here
+    // drops the premium ack flag and makes a copy-paste of the rerun command 422.
+    const items = Array.isArray(data.items) ? data.items : [];
+    const needsPremiumAck = options.acceptPremium === true
+        || data.requires_accept_premium_pricing === true
+        || items.some((item) => readRecordString(item, "tier") === "premium");
+    const flags = [
+        "--approved",
+        `--quote ${quoteId}`,
+        ...(needsPremiumAck ? ["--accept-premium"] : []),
+        ...(options.autoRenew ? ["--auto-renew"] : []),
+        ...(options.privacy === false ? ["--no-privacy"] : []),
+    ];
+    return `${resolveCliBinaryName()} domains buy ${domains.join(" ")} ${flags.join(" ")}`;
+}
+// succeeded/failed are terminal; action_required stops the wait too because
+// only the user (in the Cloudflare dashboard) can move it forward.
+function isSettledDomainRegistrationStatus(status) {
+    return status === "succeeded"
+        || status === "failed"
+        || status === "action_required";
 }
-async function waitForTableActionRun(runId, options) {
-    const timeoutSeconds = readPositiveInt(options.timeoutSeconds)
-        ?? TABLE_ACTION_RUN_WAIT_DEFAULT_TIMEOUT_SECONDS;
-    const intervalSeconds = readPositiveInt(options.intervalSeconds)
-        ?? TABLE_ACTION_RUN_WAIT_DEFAULT_INTERVAL_SECONDS;
+async function waitForDomainRegistration(domain) {
     const startedAt = Date.now();
-    const deadline = startedAt + timeoutSeconds * 1000;
+    const deadline = startedAt + DOMAIN_REGISTRATION_WAIT_TIMEOUT_SECONDS * 1000;
     let polls = 0;
-    while (true) {
-        polls += 1;
-        const latestRun = await requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}`);
-        const status = readRecordString(latestRun, "status");
-        if (isTerminalTableActionRunStatus(status)) {
+    let lastStatus = null;
+    let lastRegistration = null;
+    for (;;) {
+        let delayMs = DOMAIN_REGISTRATION_WAIT_INTERVAL_SECONDS * 1000;
+        try {
+            polls += 1;
+            const latest = await requestOxygen(`/api/cli/domains/registrations/${encodeURIComponent(domain)}`);
+            lastRegistration = readRecord(latest, "registration");
+            lastStatus = readRecordString(lastRegistration, "status");
+            if (isSettledDomainRegistrationStatus(lastStatus)) {
+                if (lastStatus === "action_required") {
+                    process.stderr.write(`hint: ${domain} needs action in the Cloudflare dashboard before registration can finish.\n`);
+                }
+                return {
+                    domain,
+                    status: lastStatus,
+                    terminal: true,
+                    polls,
+                    elapsedMs: Date.now() - startedAt,
+                    ...(lastRegistration ? { registration: lastRegistration } : {}),
+                    ...(readRecordString(latest, "deepLink") ? { deepLink: readRecordString(latest, "deepLink") } : {}),
+                };
+            }
+        }
+        catch (error) {
+            // Honor the server's rate-limit pushback instead of failing the wait.
+            const retryAfterSeconds = error instanceof OxygenError
+                ? readDetailsNumber(error.details, "retry_after_seconds")
+                : null;
+            if (retryAfterSeconds === null)
+                throw error;
+            delayMs = Math.max(delayMs, retryAfterSeconds * 1000);
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            process.stderr.write(`hint: registration for ${domain} is still ${lastStatus ?? "pending"}; the background worker keeps polling — re-run \`${resolveCliBinaryName()} domains registration-status ${domain} --wait\` later.\n`);
             return {
-                actionRun: latestRun,
-                actionRunId: readRecordString(latestRun, "id") ?? runId,
-                status,
-                terminal: true,
+                domain,
+                status: lastStatus,
+                terminal: false,
+                timed_out: true,
                 polls,
                 elapsedMs: Date.now() - startedAt,
-                ...(readRecordString(latestRun, "web_url") ? { web_url: readRecordString(latestRun, "web_url") } : {}),
+                ...(lastRegistration ? { registration: lastRegistration } : {}),
             };
         }
-        const remainingMs = deadline - Date.now();
-        if (remainingMs <= 0) {
-            throw new OxygenError("table_action_run_wait_timeout", "Timed out waiting for table action run to finish.", {
-                details: {
-                    action_run_id: runId,
-                    status: status ?? null,
-                    timeout_seconds: timeoutSeconds,
-                    polls,
-                },
-                exitCode: 1,
-            });
-        }
-        await sleep(Math.min(intervalSeconds * 1000, remainingMs));
+        await sleep(Math.min(delayMs, remainingMs));
     }
 }
 async function exportRows(table, options) {
@@ -5780,6 +6582,7 @@ async function exportRows(table, options) {
 const TABLE_BUNDLE_SCHEMA_VERSION = 1;
 const TABLE_BUNDLE_MAX_PAGE_SIZE = 1000;
 const TABLE_BUNDLE_DEFAULT_PAGE_SIZE = 500;
+// skipcq: JS-R1005 — intentional branching across describe/query pagination, column-definition normalization, and output sink (stdout/file)
 async function exportTableBundle(table, options) {
     const pageSize = Math.min(readPositiveInt(options.pageSize) ?? TABLE_BUNDLE_DEFAULT_PAGE_SIZE, TABLE_BUNDLE_MAX_PAGE_SIZE);
     // Pull the canonical schema (incl. enrichment/tool definitions and
@@ -6690,9 +7493,9 @@ async function handleProfilesCurrentAction(options) {
     }
 }
 function shellQuote(value) {
-    if (/^[A-Za-z0-9_.\-:\/@%+=]+$/.test(value))
+    if (/^[A-Za-z0-9_.\-:/@%+=]+$/.test(value))
         return value;
-    return `'${value.replace(/'/g, `'\\''`)}'`;
+    return `'${value.replace(/'/g, "'\\''")}'`;
 }
 async function handleLogoutAction(options) {
     try {
@@ -6718,7 +7521,7 @@ async function handleLogoutAction(options) {
         process.exitCode = error instanceof OxygenError ? error.exitCode : 1;
     }
 }
-async function handleUpdateAction(options) {
+function handleUpdateAction(options) {
     try {
         const result = updateCli(options);
         if (options.json) {
@@ -7375,7 +8178,7 @@ function describeProfileSource(source) {
         case "flag": return "from --profile flag";
         case "env": return "from OXYGEN_PROFILE";
         case "file": return "from stored active profile";
-        case "default": return "default fallback";
+        default: return "default fallback";
     }
 }
 function formatLogoutSuccess(result) {
@@ -7437,8 +8240,8 @@ function renderBox(lines) {
     return [border, ...body, border].join("\n");
 }
 function visibleLength(value) {
-    // skipcq: JS-0004 — ESC (\x1b) is the ANSI CSI introducer; required to strip color codes
-    return value.replace(/\x1b\[[0-9;]*m/g, "").length;
+    // skipcq: JS-0004, JS-W1035 — ESC (\x1b) is the ANSI CSI introducer; the literal escape is required to strip color codes
+    return value.replace(/\x1b\[[0-9;]*m/gu, "").length;
 }
 function ansi(enabled) {
     const wrap = (open, close) => enabled
@@ -7496,14 +8299,6 @@ function buildFeedbackBody(options) {
     }
     return body;
 }
-function splitCsvOption(value) {
-    if (!value)
-        return [];
-    return value
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0);
-}
 function buildSupportTicketBody(options) {
     const body = { subject: readOption(options.subject) };
     if (readOption(options.body))
@@ -7517,9 +8312,9 @@ function buildSupportTicketBody(options) {
         context.operation = readOption(options.operation);
     if (readOption(options.errorCode))
         context.error_code = readOption(options.errorCode);
-    const runIds = splitCsvOption(options.runIds);
-    const tableIds = splitCsvOption(options.tableIds);
-    const deepLinks = splitCsvOption(options.deepLinks);
+    const runIds = readCsvOption(options.runIds);
+    const tableIds = readCsvOption(options.tableIds);
+    const deepLinks = readCsvOption(options.deepLinks);
     if (runIds.length)
         context.run_ids = runIds;
     if (tableIds.length)
@@ -7550,12 +8345,6 @@ function readCsvOption(value) {
         .map((entry) => entry.trim())
         .filter(Boolean);
 }
-function splitCsv(value) {
-    return value
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-}
 // Assemble the optional campaign email binding from the --email-* flags. The
 // content spec (--email-definition-file) is the author-provided email sequence
 // that the API compiles to an Instantly campaign on start; provider/connection
@@ -7568,7 +8357,7 @@ function readCampaignEmailBinding(options) {
     if (!provider && !connectionId && !definitionPath)
         return undefined;
     const definition = definitionPath
-        ? JSON.parse(readFileSync(resolve(definitionPath), "utf8"))
+        ? readJsonFileValue(resolve(definitionPath), "--email-definition-file")
         : undefined;
     return {
         ...(provider ? { provider } : {}),
@@ -7588,7 +8377,7 @@ slug, options) {
     if (filePath) {
         const fs = await import("node:fs/promises");
         const raw = await fs.readFile(filePath, "utf8");
-        body.envelope = JSON.parse(raw);
+        body.envelope = parseJsonValue(raw, "--file");
     }
     const fromUrl = readOption(options.fromUrl);
     if (fromUrl) {
@@ -7603,12 +8392,7 @@ slug, options) {
     }
     const inputJson = readOption(options.inputJson);
     if (inputJson) {
-        try {
-            body.inputs = JSON.parse(inputJson);
-        }
-        catch {
-            throw new Error("--input-json must be valid JSON.");
-        }
+        body.inputs = parseJsonValue(inputJson, "--input-json");
     }
     const tableRefEntries = Array.isArray(options.tableRef) ? options.tableRef : [];
     if (tableRefEntries.length > 0) {
@@ -7742,6 +8526,7 @@ table, options) {
             ? { phone_waterfall_profile: readOption(options.phoneWaterfallProfile) }
             : {}),
         ...(options.verifyPhone ? { verify_phone: true } : {}),
+        ...(options.allowPremiumLanes ? { allow_premium_lanes: true } : {}),
         ...(readOption(options.phoneVerificationCredentialMode)
             ? { phone_verification_credential_mode: readOption(options.phoneVerificationCredentialMode) }
             : {}),