@oxygen-agent/cli 1.987.20 → 1.1003.12

package/dist/index.js

@@ -12,9 +12,10 @@ import { registerKnowledgeRepositoryCommands } from "./knowledge-repository-comm
 import { registerVisualCommands } from "./visual-commands.js";
 import { renderPrimaryProviderBoard } from "./admin-primary-providers-render.js";
 import { registerFunctionsCommands } from "./functions-commands.js";
-import { applyOxygenHelp, enableCommandSuggestions, unknownCommandHint } from "./help.js";
+import { applyOxygenHelp, enableCommandSuggestions, unknownCommandHint, unknownOptionHint } from "./help.js";
 import { buildCommandManifest, getCommandManifestEntry, searchCommandManifest, suggestCommandNames, } from "./command-manifest.js";
-import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatCopilotPlanDuration, formatCopilotPlanSeconds, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, isVersionGreater, isVersionLess, KNOWLEDGE_BOOTSTRAP_MAX_CREDITS, MAX_CLI_JSON_BODY_BYTES, MAX_MCP_TOOL_NAME_LENGTH, normalizeCopilotPlanStepStatus, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
+import { AGENCY_DIRECTORY_REGIONS, AGENCY_DIRECTORY_SERVICES, COLLAB_GATE_KINDS, COLLAB_GATE_PROSE, COLLAB_SUBJECT_KINDS, COLLAB_SUBJECT_KINDS_PROSE, COLLAB_SUBJECT_LABELS, COLLAB_SUBJECT_PROSE, GATE_KIND_SUBJECTS, describeWorkflowStatusChange, formatCellForDisplay, formatCopilotPlanDuration, formatCopilotPlanSeconds, formatPublicBudgetScopes, SUBJECT_PATH_FORMS_PROSE, formatSubjectPath, exitCodeForOxygenError, parseSubjectPath, parseSubjectRef, parseWorkflowStatusChange, chunk, isVersionGreater, isVersionLess, KNOWLEDGE_BOOTSTRAP_MAX_CREDITS, MAX_CLI_JSON_BODY_BYTES, MAX_MCP_TOOL_NAME_LENGTH, normalizeCopilotPlanStepStatus, OXYGEN_CAPABILITY_ROUTES, OXYGEN_VERSION, OxygenError, getCapabilityRouteMatch, inferUserCapabilityRoute, parseKnowledgePageMarkdown, PLAN_LIMITS, serializeCapabilityRoute, sleep, success, TABLE_IMPORT_ROW_LIMIT, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
+import { PURCHASABLE_PLAN_KEYS } from "@oxygen/shared/billing";
 import { TAG_COLORS } from "@oxygen/shared/select-options";
 import { inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
 import { MAILBOX_IMPORT_FILE_MAX_BYTES as SHARED_MAILBOX_IMPORT_FILE_MAX_BYTES, MAILBOX_IMPORT_ROW_LIMIT as SHARED_MAILBOX_IMPORT_ROW_LIMIT, normalizeMailboxImportFile as normalizeSharedMailboxImportFile, normalizeMailboxImportVendor as normalizeSharedMailboxImportVendor, normalizeMailboxWorkbookRows, parseMailboxImportText, summarizeMailboxImportValidation as summarizeSharedMailboxImportValidation, } from "@oxygen/shared/mailbox-import";
@@ -173,13 +174,55 @@ function requireCollabDecision(options) {
     }
     return selected[0];
 }
+/**
+ * A widget configuration from `--config` or `--config-file`.
+ *
+ * Both are accepted because the shape of a chart or a code widget is more than
+ * anyone wants to quote on one shell line, and `--config-file` is how an agent
+ * hands over a configuration it just generated. The SHAPE is validated server
+ * side by the shared widget registry, never here: a second validator is how the
+ * CLI and the web start disagreeing about what a valid widget is.
+ */
+async function readDashboardWidgetConfig(options) {
+    const inline = readOption(options.config);
+    const path = readOption(options.configFile);
+    if (inline && path) {
+        throw new OxygenError("invalid_request", "Pass either --config or --config-file, not both.", { exitCode: 1 });
+    }
+    if (inline)
+        return parseJsonObject(inline);
+    if (path) {
+        const fs = await import("node:fs/promises");
+        return parseJsonObject(await fs.readFile(path, "utf8"));
+    }
+    return {};
+}
 function buildFindBody(capability, options) {
     const body = { capability };
     const set = (key, value) => {
         if (value)
             body[key] = value;
     };
-    if (capability === "company") {
+    if (capability === "person") {
+        set("linkedin_url", options.linkedinUrl);
+        set("linkedin_id", options.linkedinId);
+        set("sales_navigator_url", options.salesNavigatorUrl);
+        set("email", options.email);
+        set("full_name", options.fullName);
+        set("first_name", options.firstName);
+        set("last_name", options.lastName);
+        set("company_domain", options.companyDomain);
+        set("company_name", options.companyName);
+        if (options.includeRaw)
+            body.include_raw = true;
+    }
+    else if (capability === "company") {
+        // The catalog needs no identity and spends nothing; it is the answer to
+        // "which fields exist and what do they cost" before any field is named.
+        if (options.listFields) {
+            body.list_fields = true;
+            return body;
+        }
         set("domain", options.domain);
         set("name", options.name);
         set("linkedin_url", options.linkedinUrl);
@@ -188,6 +231,11 @@ function buildFindBody(capability, options) {
             if (fields.length > 0)
                 body.fields = fields;
         }
+        if (options.checkTechnologies) {
+            const technologies = options.checkTechnologies.split(",").map((entry) => entry.trim()).filter(Boolean);
+            if (technologies.length > 0)
+                body.check_technologies = technologies;
+        }
     }
     else {
         set("linkedin_url", options.linkedinUrl);
@@ -843,6 +891,29 @@ function writeEngagersReceipt(data) {
 // reported as broken: the preview comes back empty and reads as a failed live
 // call. Mirror the server's preview banner on stderr, the same stdout/stderr
 // split the credits receipt uses, so the machine-read envelope stays clean.
+/**
+ * Say WHY a preview found nothing, before the preview itself.
+ *
+ * A dry run against a tool the workspace has no connection for comes back as a
+ * clean, successful-looking envelope whose refusal lives several levels down in
+ * `access.status`. Read top-down, that is indistinguishable from "this provider
+ * has nothing for you" — which is how a blind operator concluded a whole
+ * provider could never be reached. When the route states `would_execute: false`
+ * with a `blocked_by` list, put it on stderr in one line, next to the fix.
+ * Absent those fields nothing is printed, so every other tool run is unchanged.
+ */
+function writeToolRunBlockedNotice(data) {
+    const payload = asPayloadRecord(data);
+    if (!payload || payload.would_execute !== false)
+        return;
+    const blockedBy = Array.isArray(payload.blocked_by)
+        ? payload.blocked_by.filter((entry) => typeof entry === "string")
+        : [];
+    if (blockedBy.length === 0)
+        return;
+    const nextAction = typeof payload.next_action === "string" ? payload.next_action : null;
+    process.stderr.write(`Blocked: ${blockedBy.join(", ")}${nextAction ? ` — ${nextAction}` : ""}\n`);
+}
 function writeDryRunNotice(data) {
     if (!data || typeof data !== "object" || Array.isArray(data))
         return;
@@ -1055,14 +1126,14 @@ function writeObservabilityCapsNotice(data) {
 // answer, so say it on stderr — same treatment the observability console's
 // per-source cap already gets. Machine-read stdout carries `capped`, `returned`
 // and `limit` either way.
-function writeListCapNotice(data, noun) {
+function writeListCapNotice(data, noun, hint) {
     if (!data || typeof data !== "object" || Array.isArray(data))
         return;
     const record = data;
     if (record.capped !== true)
         return;
     const returned = typeof record.returned === "number" ? record.returned : null;
-    process.stderr.write(`note: showing ${returned === null ? "a window of" : returned} ${noun}; more exist — raise --limit (max 1000) or pass --all.\n`);
+    process.stderr.write(`note: showing ${returned === null ? "a window of" : returned} ${noun}; more exist — raise --limit (max 1000) or pass --all${hint ? `; ${hint}` : ""}.\n`);
 }
 // The map is bounded twice over — a scan window per kind, then a character
 // budget across all of them — and both bounds are invisible in the rendered
@@ -2748,6 +2819,36 @@ function buildCrmTimelinePath(object, rowId, options) {
     const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/timeline`;
     return query ? `${base}?${query}` : base;
 }
+function buildCrmRelatedPath(object, rowId, options) {
+    const params = new URLSearchParams();
+    if (options.previewLimit)
+        params.set("preview_limit", options.previewLimit);
+    const query = params.toString();
+    const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/related`;
+    return query ? `${base}?${query}` : base;
+}
+function buildCrmNotesPath(object, rowId, options) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set("limit", options.limit);
+    if (options.cursor)
+        params.set("cursor", options.cursor);
+    const query = params.toString();
+    const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/notes`;
+    return query ? `${base}?${query}` : base;
+}
+function buildCrmTasksPath(object, rowId, options) {
+    const params = new URLSearchParams();
+    if (options.status)
+        params.set("status", options.status);
+    if (options.limit)
+        params.set("limit", options.limit);
+    if (options.cursor)
+        params.set("cursor", options.cursor);
+    const query = params.toString();
+    const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tasks`;
+    return query ? `${base}?${query}` : base;
+}
 function buildCrmPipelinePath(options) {
     const params = new URLSearchParams();
     if (readOption(options.pipeline))
@@ -4790,10 +4891,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     })));
     program
         .command("dashboards")
-        .description("Default GTM dashboards: the stitched Command Center funnel across the sequencer, unibox, and CRM.")
+        .description("Your saved dashboards, plus the built-in GTM funnel. `summary` reads the built-in Command Center funnel across the sequencer, unibox and CRM; everything else creates and edits dashboards you save yourself and open again later, from charts, saved table views, notes, embeds and live sources.")
         .addCommand(new Command("summary")
         .description("Show the GTM funnel summary: touches → replies → positive → meetings → deals → won, with this-period revenue, channel split, and needs-action triage counts.")
-        .option("--range <range>", "Preset range: 7d, 14d, 28d, or 30d. Defaults to 14d.")
+        .option("--range <range>", "Preset range: 7d, 14d, 28d, 30d, 90d, 180d, 365d, or all. Defaults to 14d.")
         .option("--from <date>", "Custom start date (YYYY-MM-DD).")
         .option("--to <date>", "Custom end date (YYYY-MM-DD).")
         .option("--cold-deal-days <n>", "Days of no activity before an open deal counts as cold. Defaults to 14.")
@@ -4816,7 +4917,187 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const qs = params.toString();
             return requestOxygen(`/api/cli/dashboards/summary${qs ? `?${qs}` : ""}`);
         });
-    }));
+    }))
+        .addCommand(new Command("list")
+        .description("List the dashboards saved in this workspace.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("dashboards list", options, () => requestOxygen("/api/cli/dashboards"));
+    }))
+        .addCommand(new Command("create")
+        .description("Create a saved dashboard. It starts with one empty tab; add widgets to it with `dashboards widgets add`.")
+        .argument("<name>", "Display name, e.g. \"Monday numbers\".")
+        .option("--slug <slug>", "URL handle. Defaults to a slug derived from the name.")
+        .option("--description <text>", "What this dashboard answers.")
+        .option("--icon <icon>", "Icon name shown beside it in the CRM sidebar.")
+        .option("--default", "Open this one when the dashboards page is opened with no dashboard named.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (name, options) => {
+        await handleAsyncAction("dashboards create", options, () => {
+            const body = { name };
+            const slug = readOption(options.slug);
+            const description = readOption(options.description);
+            const icon = readOption(options.icon);
+            if (slug)
+                body.slug = slug;
+            if (description)
+                body.description = description;
+            if (icon)
+                body.icon = icon;
+            if (options.default)
+                body.is_default = true;
+            return requestOxygen("/api/cli/dashboards", { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Read one dashboard with its tabs and widgets.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, options) => {
+        await handleAsyncAction("dashboards get", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}`));
+    }))
+        .addCommand(new Command("update")
+        .description("Rename a dashboard, change its description or icon, or make it the default.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .option("--name <name>", "New display name.")
+        .option("--description <text>", "New description. Pass an empty string to clear it.")
+        .option("--icon <icon>", "New icon name.")
+        .option("--default", "Make this the default dashboard.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, options) => {
+        await handleAsyncAction("dashboards update", options, () => {
+            const body = {};
+            if (options.name !== undefined)
+                body.name = options.name;
+            if (options.description !== undefined)
+                body.description = options.description;
+            if (options.icon !== undefined)
+                body.icon = options.icon;
+            if (options.default)
+                body.is_default = true;
+            return requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}`, {
+                method: "PATCH",
+                body,
+            });
+        });
+    }))
+        .addCommand(new Command("delete")
+        .description("Archive a dashboard. Its slug becomes free to reuse; the definition is kept, not destroyed.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, options) => {
+        await handleAsyncAction("dashboards delete", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}`, {
+            method: "DELETE",
+        }));
+    }))
+        .addCommand(new Command("tabs")
+        .description("Tabs inside a dashboard.")
+        .addCommand(new Command("add")
+        .description("Add a tab to a dashboard.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<title>", "Tab title.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, title, options) => {
+        await handleAsyncAction("dashboards tab create", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/tabs`, {
+            method: "POST",
+            body: { title },
+        }));
+    }))
+        .addCommand(new Command("remove")
+        .description("Remove a tab and every widget on it. A dashboard always keeps at least one tab.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<tab_id>", "Tab id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, tabId, options) => {
+        await handleAsyncAction("dashboards tab delete", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/tabs?tab=${encodeURIComponent(tabId)}`, { method: "DELETE" }));
+    })))
+        .addCommand(new Command("widgets")
+        .description("Widgets on a dashboard: charts, saved views, embeds, notes, custom code, and live sources. `kinds` shows every configuration shape; `data` reads back the numbers a widget actually draws.")
+        .addCommand(new Command("kinds")
+        .description("List the widget kinds, what each one shows, whether it can cost credits, and an example configuration.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("dashboards widget kinds", options, () => requestOxygen("/api/cli/dashboards/widget-kinds"));
+    }))
+        .addCommand(new Command("add")
+        .description("Add a widget. Kinds: chart, view, iframe, rich_text, code, live_source. The configuration shape depends on the kind — run `oxygen dashboards widgets kinds` to see each one with an example.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<kind>", "chart | view | iframe | rich_text | code | live_source")
+        .argument("<title>", "Widget title.")
+        .option("--tab <tab_id>", "Tab to place it on. Defaults to the dashboard's first tab.")
+        .option("--config <json>", "Widget configuration as JSON.")
+        .option("--config-file <path>", "Read the configuration JSON from a file.")
+        .option("--position <json>", "Grid placement as JSON, e.g. '{\"x\":0,\"y\":0,\"w\":6,\"h\":4}'.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, kind, title, options) => {
+        await handleAsyncAction("dashboards widget add", options, async () => {
+            const body = { kind, title };
+            const tab = readOption(options.tab);
+            if (tab)
+                body.tab = tab;
+            body.configuration = await readDashboardWidgetConfig(options);
+            const position = readOption(options.position);
+            if (position)
+                body.position = parseJsonObject(position);
+            return requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/widgets`, { method: "POST", body });
+        });
+    }))
+        .addCommand(new Command("update")
+        .description("Change a widget's title, configuration or placement, or pause/resume a live source.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<widget_id>", "Widget id.")
+        .option("--title <title>", "New title.")
+        .option("--config <json>", "Replacement configuration as JSON. Replaces the whole configuration, never merged.")
+        .option("--config-file <path>", "Read the replacement configuration JSON from a file.")
+        .option("--position <json>", "New grid placement as JSON.")
+        .option("--pause", "Stop a live-source widget refreshing. It keeps showing its last result.")
+        .option("--resume", "Let a paused live-source widget refresh again.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, widgetId, options) => {
+        await handleAsyncAction("dashboards widget update", options, async () => {
+            if (options.pause && options.resume) {
+                throw new OxygenError("invalid_request", "Choose one of --pause or --resume, not both.", { exitCode: 1 });
+            }
+            const body = { widget: widgetId };
+            if (options.title !== undefined)
+                body.title = options.title;
+            if (readOption(options.config) || readOption(options.configFile)) {
+                body.configuration = await readDashboardWidgetConfig(options);
+            }
+            const position = readOption(options.position);
+            if (position)
+                body.position = parseJsonObject(position);
+            if (options.pause)
+                body.is_paused = true;
+            if (options.resume)
+                body.is_paused = false;
+            return requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/widgets`, { method: "PATCH", body });
+        });
+    }))
+        .addCommand(new Command("remove")
+        .description("Remove a widget from a dashboard.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<widget_id>", "Widget id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, widgetId, options) => {
+        await handleAsyncAction("dashboards widget remove", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/widgets?widget=${encodeURIComponent(widgetId)}`, { method: "DELETE" }));
+    }))
+        .addCommand(new Command("refresh")
+        .description("Refresh a live-source widget now. This is the only dashboard command that can cost credits, bounded by the ceiling saved on the widget. Opening a dashboard never spends.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<widget_id>", "Widget id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, widgetId, options) => {
+        await handleAsyncAction("dashboards widget refresh", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/widgets/${encodeURIComponent(widgetId)}/refresh`, { method: "POST" }));
+    }))
+        .addCommand(new Command("data")
+        .description("Read the data behind one widget — the same numbers the web page draws.")
+        .argument("<dashboard>", "Dashboard slug or id.")
+        .argument("<widget_id>", "Widget id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (dashboard, widgetId, options) => {
+        await handleAsyncAction("dashboards widget data", options, () => requestOxygen(`/api/cli/dashboards/${encodeURIComponent(dashboard)}/widgets/${encodeURIComponent(widgetId)}/data`));
+    })));
     program
         .command("crm")
         .description("Agent-native CRM object setup, records, automatic enrichment, and metadata commands.")
@@ -4881,14 +5162,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("List configured CRM objects, or create/extend custom objects.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("crm objects", options, () => requestOxygen("/api/cli/crm/objects"));
+        await handleReadActionWithLens("crm objects", options, () => requestOxygen("/api/cli/crm/objects"), formatCrmObjects);
     })
         .addCommand(new Command("create")
         .description("Create or repair a custom CRM object. Defaults to dry-run.")
         .requiredOption("--slug <slug>", "Object slug (snake_case), such as projects or tasks.")
         .requiredOption("--display-name <name>", "Human-readable object name, such as Projects.")
         .requiredOption("--columns-json <json>", 'JSON array. Every column requires key,label,data_type,semantic_type; camelCase aliases are accepted. Example: [{"key":"name","label":"Name","data_type":"text","semantic_type":"text","is_record_label":true}].')
-        .option("--identities-json <json>", "JSON array. Every identity requires column_key and normalization; camelCase columnKey is accepted.")
+        .option("--identities-json <json>", "JSON array. Every identity requires column_key and normalization; camelCase columnKey is accepted. normalization is one of email_v1, domain_v1, linkedin_url_v1, exact_text_v1, uuid_v1 — the versioned CRM names, NOT the short exact/email/domain spellings --lookup-normalize takes. At most one identity may set is_primary.")
         .option("--label-column <key>", "Column key to use as the record label. Defaults to the isRecordLabel column or the first column.")
         .option("--singular-name <name>", "Singular display name, such as Project.")
         .option("--plural-name <name>", "Plural display name, such as Projects.")
@@ -4925,10 +5206,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("add-attr")
-        .description("Add one attribute to an existing custom CRM object, optionally as an identity. Defaults to dry-run.")
-        .argument("<object>", "Custom CRM object slug, such as projects or tasks. Standard objects are managed by `crm setup`.")
+        .description("Add one field to an existing CRM object, optionally as an identity. Works on custom objects and on companies/people/deals — a field you add is yours and survives `crm setup`. Defaults to dry-run.")
+        .argument("<object>", "CRM object slug, such as companies, people, deals, or a custom object like projects.")
         .requiredOption("--column-json <json>", "JSON column. Required: key,label,data_type,semantic_type; camelCase aliases are accepted.")
-        .option("--as-identity-json <json>", "JSON identity definition {columnKey,normalization,isPrimary?} promoting the new column.")
+        .option("--as-identity-json <json>", "JSON identity definition {columnKey,normalization,isPrimary?} promoting the new column. normalization is one of email_v1, domain_v1, linkedin_url_v1, exact_text_v1, uuid_v1.")
         .option("--dry-run", "Preview the attribute plan without altering the table.")
         .option("--live", "Apply the attribute. Default is dry-run.")
         .option("--json", "Print a JSON envelope.")
@@ -4958,7 +5239,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("Create or update one CRM record by object identity. Defaults to dry-run. A live assert fires the object's standing auto-run (automatic enrichment) for the written record, exactly like `tables insert|upsert|import` — so new records enrich hands-free within the per-batch credit cap. Inspect or change what runs with `oxygen crm enrichment list`.")
         .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("--values-json <json>", "JSON object of CRM attribute values keyed by column key. RELATIONSHIP columns (a deal's Associated Company and Associated People, a person's Company) are not set here and are silently ignored if you try: link by the target's identity with `company_domain` (people and deals) or `primary_contact_email` (deals), or attach an existing record with `oxygen crm relationships upsert`.")
         .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.")
@@ -4975,6 +5256,220 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .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("connections")
+        .description("Show the conversations and sequence enrollments connected to one CRM record, resolved through its people and identities \u2014 never by fuzzy name or domain.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .option("--conversation-limit <n>", "Maximum conversations to return.")
+        .option("--sequence-limit <n>", "Maximum sequence enrollments to return.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm connections", options, () => {
+            const params = new URLSearchParams();
+            if (options.conversationLimit)
+                params.set("conversation_limit", options.conversationLimit);
+            if (options.sequenceLimit)
+                params.set("sequence_limit", options.sequenceLimit);
+            const query = params.toString();
+            const base = `/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/connections`;
+            return requestOxygen(query ? `${base}?${query}` : base);
+        });
+    }))
+        .addCommand(new Command("files")
+        .description("Attach, list, download and remove files on a CRM record. The bytes live in the workspace file store, which owns dedupe, the per-file ceiling and the retained-bytes quota.")
+        .addCommand(new Command("list")
+        .description("List one record's attachments, newest first.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm files list", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/files`));
+    }))
+        .addCommand(new Command("attach")
+        .description("Upload a local file and attach it to a CRM record. Attaching the same file twice is a no-op, not a duplicate.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .argument("<path>", "Local file path.")
+        .option("--label <label>", "What to call it on this record. The stored file keeps its own filename.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, filePath, options) => {
+        await handleAsyncAction("crm files attach", options, async () => {
+            const { readFile } = await import("node:fs/promises");
+            const { basename } = await import("node:path");
+            const bytes = await readFile(filePath);
+            return requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/files`, {
+                method: "POST",
+                body: {
+                    name: basename(filePath),
+                    content_base64: bytes.toString("base64"),
+                    ...(readOption(options.label) ? { label: readOption(options.label) } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("detach")
+        .description("Remove a file from a record. Removes the LINK only \u2014 the stored file is kept, so anywhere else it is attached still has it.")
+        .argument("<attachment_id>", "Attachment id from `crm files list`. Not the stored file id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (attachmentId, options) => {
+        await handleAsyncAction("crm files detach", options, () => requestOxygen(`/api/cli/crm/files/${encodeURIComponent(attachmentId)}`, {
+            method: "DELETE",
+        }));
+    })))
+        .addCommand(new Command("tasks")
+        .description("Read and write a CRM record's tasks \u2014 the human to-do attached to a record. Distinct from `oxygen voice tasks`, which is the phone queue a rep dials from.")
+        .addCommand(new Command("list")
+        .description("List one record's tasks. Open work first, then by deadline; an undated task sorts last inside its group rather than first.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .option("--status <status>", "Filter to open, completed or cancelled.")
+        .option("--limit <n>", "Maximum tasks to return. Defaults to 50.")
+        .option("--cursor <cursor>", "Pagination cursor from a previous page.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm tasks list", options, () => requestOxygen(buildCrmTasksPath(object, rowId, options)));
+    }))
+        .addCommand(new Command("add")
+        .description("Create a task on a CRM record. Free and internal, so it writes immediately rather than previewing first.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .argument("<title>", "What needs doing.")
+        .option("--body <body>", "Longer description.")
+        .option("--priority <priority>", "urgent, high, medium or low.")
+        .option("--due <iso>", "ISO-8601 due timestamp. An unparseable value is rejected, never silently dropped.")
+        .option("--assignee <user_id>", "Workspace member to assign it to. Unassigned means the team, not nobody.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, title, options) => {
+        await handleAsyncAction("crm tasks add", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/tasks`, {
+            method: "POST",
+            body: {
+                title,
+                ...(readOption(options.body) ? { body: readOption(options.body) } : {}),
+                ...(readOption(options.priority) ? { priority: readOption(options.priority) } : {}),
+                ...(readOption(options.due) ? { due_at: readOption(options.due) } : {}),
+                ...(readOption(options.assignee) ? { assignee_actor_id: readOption(options.assignee) } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("update")
+        .description("Change a task's title, body, status, priority, deadline or assignee. Addressed by task id because one task can be filed on several records.")
+        .argument("<task_id>", "Task id.")
+        .option("--title <title>", "Replacement title.")
+        .option("--body <body>", "Replacement description. Pass an empty string to clear it.")
+        .option("--status <status>", "open, completed or cancelled.")
+        .option("--priority <priority>", "urgent, high, medium, low, or an empty string to clear it.")
+        .option("--due <iso>", "ISO-8601 due timestamp, or an empty string to clear the deadline.")
+        .option("--assignee <user_id>", "Workspace member, or an empty string to unassign.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (taskId, options) => {
+        await handleAsyncAction("crm tasks update", options, () => {
+            const body = readOption(options.body);
+            const priority = readOption(options.priority);
+            const due = readOption(options.due);
+            const assignee = readOption(options.assignee);
+            return requestOxygen(`/api/cli/crm/tasks/${encodeURIComponent(taskId)}`, {
+                method: "PATCH",
+                body: {
+                    ...(readOption(options.title) ? { title: readOption(options.title) } : {}),
+                    ...(readOption(options.status) ? { status: readOption(options.status) } : {}),
+                    ...(body !== undefined ? { body: body === "" ? null : body } : {}),
+                    ...(priority !== undefined ? { priority: priority === "" ? null : priority } : {}),
+                    ...(due !== undefined ? { due_at: due === "" ? null : due } : {}),
+                    ...(assignee !== undefined
+                        ? { assignee_actor_id: assignee === "" ? null : assignee }
+                        : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("complete")
+        .description("Mark a task done. Completing an already-completed task keeps the original completion time and adds no second timeline entry.")
+        .argument("<task_id>", "Task id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (taskId, options) => {
+        await handleAsyncAction("crm tasks complete", options, () => requestOxygen(`/api/cli/crm/tasks/${encodeURIComponent(taskId)}`, {
+            method: "PATCH",
+            body: { status: "completed" },
+        }));
+    }))
+        .addCommand(new Command("reopen")
+        .description("Reopen a completed task, clearing its completion stamp.")
+        .argument("<task_id>", "Task id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (taskId, options) => {
+        await handleAsyncAction("crm tasks reopen", options, () => requestOxygen(`/api/cli/crm/tasks/${encodeURIComponent(taskId)}`, {
+            method: "PATCH",
+            body: { status: "open" },
+        }));
+    })))
+        .addCommand(new Command("notes")
+        .description("Read and write a CRM record's notes. A note is editable, pinnable and authored \u2014 and still lands on the record's timeline.")
+        .addCommand(new Command("list")
+        .description("List one record's notes, pinned first then newest. Address the record by row id OR by any of the object's identities.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .option("--limit <n>", "Maximum notes to return. Defaults to 25.")
+        .option("--cursor <cursor>", "Pagination cursor from a previous page.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm notes list", options, () => requestOxygen(buildCrmNotesPath(object, rowId, options)));
+    }))
+        .addCommand(new Command("add")
+        .description("Write a note on a CRM record. Free, internal, and editable afterwards, so it writes immediately rather than previewing first.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .argument("<body>", "Note text. Markdown.")
+        .option("--title <title>", "Optional note title.")
+        .option("--pin", "Pin the note to the top of the record's notes.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, body, options) => {
+        await handleAsyncAction("crm notes add", options, () => requestOxygen(`/api/cli/crm/objects/${encodeURIComponent(object)}/records/${encodeURIComponent(rowId)}/notes`, {
+            method: "POST",
+            body: {
+                body,
+                ...(readOption(options.title) ? { title: readOption(options.title) } : {}),
+                ...(options.pin ? { pinned: true } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("update")
+        .description("Edit a note's body, title or pin. Addressed by note id because one note can be filed on several records.")
+        .argument("<note_id>", "Note id.")
+        .option("--body <body>", "Replacement note text.")
+        .option("--title <title>", "Replacement title. Pass an empty string to clear it.")
+        .option("--pin", "Pin the note.")
+        .option("--unpin", "Unpin the note.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (noteId, options) => {
+        await handleAsyncAction("crm notes update", options, () => {
+            const title = readOption(options.title);
+            return requestOxygen(`/api/cli/crm/notes/${encodeURIComponent(noteId)}`, {
+                method: "PATCH",
+                body: {
+                    ...(readOption(options.body) ? { body: readOption(options.body) } : {}),
+                    ...(title !== undefined ? { title } : {}),
+                    ...(options.pin ? { pinned: true } : {}),
+                    ...(options.unpin ? { pinned: false } : {}),
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("delete")
+        .description("Delete a note. Soft: the note stops showing its text while its place in the timeline stays, so the record still shows that a note was written and removed.")
+        .argument("<note_id>", "Note id.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (noteId, options) => {
+        await handleAsyncAction("crm notes delete", options, () => requestOxygen(`/api/cli/crm/notes/${encodeURIComponent(noteId)}`, { method: "DELETE" }));
+    })))
+        .addCommand(new Command("related")
+        .description("Show the records linked to one CRM record, grouped by relationship with a true count per group. Address the record by row id OR by any of the object's identities \u2014 a company domain, a person's email or LinkedIn URL.")
+        .argument("<object>", "CRM object slug, such as companies or people.")
+        .argument("<record>", "CRM record row id, or an identity value such as acme.com or sarah@acme.com.")
+        .option("--preview-limit <n>", "Linked records to preview per group. Defaults to 6, max 50. The count is always the real total.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (object, rowId, options) => {
+        await handleAsyncAction("crm related", options, () => requestOxygen(buildCrmRelatedPath(object, rowId, options)));
     }))
         .addCommand(new Command("tag")
         .description("Add/remove workspace tags on one CRM record (Tags primitive — the same vocabulary as sequences, tables, conversations; see `oxygen tags list`). Delta semantics: --add unions, --remove subtracts, remove wins. Standard objects carry the tags attribute after `oxygen crm setup`.")
@@ -5481,6 +5976,20 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     const tablesCommand = program
         .command("tables")
         .description("Tenant workspace table commands.")
+        .addCommand(new Command("sources")
+        .description("List every way a table can start — imports, company/people/signal sources, webhooks, functions — with the provider count and per-row credit estimate behind each. Free; nothing is called or written. The same catalog the web New table picker shows.")
+        .option("--group <group>", "Only one group: Imports, Companies, People, Signals, or Tables.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tables sources", options, () => {
+            const params = new URLSearchParams();
+            const group = readOption(options.group);
+            if (group)
+                params.set("group", group);
+            const qs = params.toString() ? `?${params.toString()}` : "";
+            return requestOxygen(`/api/cli/tables/sources${qs}`);
+        });
+    }))
         .addCommand(new Command("create")
         .description("Create a real Postgres-backed workspace table. Free — 0 Oxygen credits. To create a table and import a file in one step, use `tables import --create <name>`.")
         .argument("<name>", "Display name for the table.")
@@ -5603,7 +6112,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("import")
         .description(`Import JSON, JSONL, CSV, or XLSX rows into a workspace table. The table write is free — 0 Oxygen credits. Files over ${LARGE_IMPORT_BACKGROUND_ROW_THRESHOLD} rows load durably in the background: the command returns a queued envelope and rows keep landing after it exits, so wait with the printed 'table-ingestions wait <id>' before reading row counts. ${IMPORT_FILE_LIMIT_HELP}`)
         .argument("[table]", "Table id or slug. Omit when using --create.")
-        .requiredOption("--file <path>", "Input file path.")
+        .option("--file <path>", "Input file path. Pass this or --url.")
+        .option("--url <https-link>", "Public link to fetch instead of a local file: a CSV, TSV, JSON, JSONL or XLSX file, or a Google Sheet shared with anyone-with-the-link or published to the web. Fetched server-side, up to 10 MB, 0 credits.")
+        .option("--preview", "With --url: fetch and show the columns, a row sample and the row count without creating or writing anything.")
         .option("--format <format>", "json, jsonl, csv, or xlsx. Defaults from file extension.")
         .option("--sheet <name>", "Worksheet name for XLSX imports. Defaults to the first sheet.")
         .option("--create <name>", "Create a new table with columns inferred from the file before importing.")
@@ -5675,13 +6186,15 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 params.set("all", "true");
             const qs = params.toString() ? `?${params.toString()}` : "";
             const data = await requestOxygen(`/api/cli/tables${qs}`);
+            // A capped list is where a blind agent filtered 200 rows locally to find
+            // one table by name (acceptance run, 2026-09-18); name the native lookup.
             if (!options.json)
-                writeListCapNotice(data, "table(s)");
+                writeListCapNotice(data, "table(s)", "find one by name with `workspace map --kind table --query <text>`");
             return data;
         });
     }))
         .addCommand(new Command("query")
-        .description("Query a workspace table by id or slug.")
+        .description("Query a workspace table by id or slug. Output is a JSON envelope; for a typed, human-readable rendering of the same rows use `tables export <table> --format table`.")
         .argument("<table>", "Table id or slug.")
         .option("--limit <n>", "Maximum rows to return. Defaults to 100; hard cap is 1000.")
         .option("--cursor <cursor>", "Pagination cursor returned by a previous query. Walks forward one page at a time; mutually exclusive with --offset.")
@@ -5689,6 +6202,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--fields <columns>", "Comma-separated column keys or ids to include.")
         .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\"}]}'. Add \"path\":\"a.b\" to a leaf to match a key inside a JSON cell, e.g. the rows one Function run touched: {\"columnKey\":\"<function_column>\",\"path\":\"action_run_id\",\"operator\":\"is\",\"value\":\"<run_id>\"}. Mutually exclusive with --filter-json.")
+        .option("--search <text>", "Find rows by one piece of text, matched against every text, number, date and checkbox column at once — the grid's magnifier. Combines with --filter-tree-json (both must hold). Use --filter-tree-json when you know which column to match.")
         .option("--formula-values <mode>", "Formula filters are refused by default because displayed formulas are evaluated live. Refresh the formula's stored cells with `columns run <table> <column> --force` (0 credits), then pass 'materialized'; filtering uses that stored snapshot and returns a freshness note.")
         .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).")
@@ -5720,6 +6234,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                     ...(readOption(options.fields) ? { fields: readCsvOption(options.fields) } : {}),
                     ...(filters ? { filters } : {}),
                     ...(filterTree ? { filterTree } : {}),
+                    ...(readOption(options.search) ? { search: readOption(options.search) } : {}),
                     ...(formulaValues ? { formula_values: formulaValues } : {}),
                     ...(sorts ? { sorts } : {}),
                     ...(options.systemFields === false ? { include_system_fields: false } : {}),
@@ -5753,7 +6268,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("describe")
-        .description("Describe a workspace table and its columns. Add --stats for row count and per-column fill rates (0 credits).")
+        .alias("get")
+        .description("Describe a workspace table and its columns. Add --stats for row count and per-column fill rates (0 credits). Next: `tools search --for-table <table>` lists what these columns can be enriched with and what each costs per row (0 credits).")
         .argument("<table>", "Table id or slug.")
         .option("--include-archived", "Include archived columns.")
         .option("--stats", "Include summary stats: exact row count and per-column fill rates. Exact at or under 100 rows; above that fill rates come from a 100-row sample (summary.statsSampled, summary.statsSampledRowCount) while rowCount stays exact. For whole-table fill rates on a bigger list use `tables preview <table> --summary-only` \u2014 exact up to 20,000 rows, 2,000-row sample above. 0 credits.")
@@ -6336,6 +6852,14 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         autoRunStatus: options.autoRunStatus,
         limit: options.limit,
     }))))));
+    // One authoritative statement of the config shape, on the flag that stores
+    // it. The previous copy — "(filters, sorts, columns, group). Usually written
+    // by the app." — named the LEGACY key and disowned the flag; a blind-eval
+    // agent (2026-09-20) followed it, wrote {"group":{"columnKey":...}}, and got a
+    // board that grouped by accident. --group-by is the plain path; this is the
+    // full one, and it says which key is the grouping key.
+    const TABLE_VIEW_CONFIG_HELP = 'JSON view config, typed v2 shape: {"version":2,"groupBy":"<select column key>","filterTree":{...},"sorts":[{"columnKey":"...","direction":"asc|desc"}],"visibleColumns":["..."],"cardFields":["..."]}. '
+        + 'groupBy is the kanban group-by column (--group-by sets it for you); a complete board config is \'{"version":2,"groupBy":"lifecycle_stage"}\'. Malformed v2 is rejected with invalid_view_config.';
     tablesCommand.addCommand(new Command("views")
         .description("Create and manage saved table views (grid / kanban configurations).")
         .addCommand(new Command("list")
@@ -6353,8 +6877,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .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("--view-type <type>", "table (grid) or kanban (board split into lanes by a select/status column). Defaults to table; --group-by implies kanban. A kanban created without --group-by is not refused: the board renders on the table's first groupable column and every read reports that fallback as effective_group_by plus a warning, so pin the column with --group-by.")
+        .option("--group-by <column>", "Kanban: the editable select/status column key the board splits on, e.g. --group-by lifecycle_stage. Unknown or non-groupable keys are refused with the groupable candidates. The response's effective_group_by is the column the board actually uses.")
+        .option("--config <json>", TABLE_VIEW_CONFIG_HELP)
         .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", {
@@ -6363,6 +6888,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             table,
             name: readOption(options.name),
             ...(readOption(options.viewType) ? { view_type: readOption(options.viewType) } : {}),
+            ...(readOption(options.groupBy) ? { group_by: readOption(options.groupBy) } : {}),
             ...(readOption(options.config)
                 ? { config: parseJsonValue(readOption(options.config) ?? "", "--config") }
                 : {}),
@@ -6374,8 +6900,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .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("--view-type <type>", "table (grid) or kanban (board). A kanban whose config names no group column renders on the first groupable column; reads report that fallback as effective_group_by plus a warning.")
+        .option("--group-by <column>", "Kanban: change the select/status column the board splits on; folds into the stored config and keeps the rest of it. Refused for a grid view unless --view-type kanban is passed with it.")
+        .option("--config <json>", `${TABLE_VIEW_CONFIG_HELP} 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.")
@@ -6386,6 +6913,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             view,
             ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
             ...(readOption(options.viewType) ? { view_type: readOption(options.viewType) } : {}),
+            ...(readOption(options.groupBy) ? { group_by: readOption(options.groupBy) } : {}),
             ...(readOption(options.config)
                 ? { config: parseJsonValue(readOption(options.config) ?? "", "--config") }
                 : {}),
@@ -6539,18 +7067,26 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action((feed, options) => handleAsyncAction("feeds get", options, () => requestOxygen(feedsGetPath(feed, options)))))
         .addCommand(new Command("bind")
-        .description("Bind a pull feed to an existing table: freeze the provider request, then optionally arm a cadence so the table refills itself. Arming a cadence on a paid provider is a STANDING spend grant — it requires --every, --max-credits, and --approved together. Without --every the feed is stored disarmed and nothing runs until you set a cadence.")
-        .argument("<table>", "Table id or slug that receives the rows.")
-        .requiredOption("--kind <kind>", "Feed kind: company_search or signal_search.")
-        .requiredOption("--tool-id <tool>", "Provider tool id the cycle calls, e.g. blitzapi.job_search.")
-        .requiredOption("--request-json <json-or-file>", "Provider request JSON for the tool, inline or a path to a JSON file. Take it from the plan route's `request`.")
+        .description("Bind a feed to a table: a scheduled provider harvest (pull), with --schema-json a typed-or-rejected push feed, or with --source rb2b the web-intent feed landing RB2B website-visit reveals as rows. A pull feed freezes the provider request into an existing table, then optionally arms a cadence so the table refills itself; arming a cadence on a paid provider is a STANDING spend grant — it requires --every, --max-credits, and --approved together, and without --every the feed is stored disarmed until you set one. A push feed is free: it returns a webhook URL and a secret shown once, refuses a delivery that does not match the schema with HTTP 422 (recorded in `oxygen feeds deliveries`, nothing written), and can create its table from the schema with --create <name>. `--source rb2b` is the web intent feed: OXYGEN already receives your RB2B website-visit reveals and records each one as a website_visit Signal, and this feed ALSO lands them as rows you can enrich, score, and sequence. It has no address, no schema, and no cadence to configure — the reveal shape is fixed — so binding is free and each reveal costs 0 credits on arrival. If RB2B is not connected to this workspace yet, rows only start once it is; there is no self-serve connect step yet.")
+        .argument("[table]", "Table id or slug that receives the rows. Required for a pull feed; a push or web-intent feed takes it or --create <name>.")
+        .option("--kind <kind>", "Pull feed, required. Feed kind: company_search or signal_search.")
+        .option("--tool-id <tool>", "Pull feed, required. Provider tool id the cycle calls, e.g. blitzapi.job_search.")
+        .option("--request-json <json-or-file>", "Pull feed, required. Provider request JSON for the tool, inline or a path to a JSON file. Take it from the plan route's `request`.")
+        .option("--schema-json <json-or-file>", "Bind a PUSH feed instead: the JSON Schema (an object with type, properties, required, additionalProperties) every delivered row must match, inline or a path to a JSON file.")
+        .option("--source <source>", `Bind a WEB INTENT push feed instead: ${FEED_BIND_WEB_INTENT_SOURCES.join(", ")} (rb2b = the website-visit reveals OXYGEN already receives for this workspace, also kept as website_visit Signals). Fixed row shape, no schema, no cadence, 0 credits per reveal. Takes a table or --create <name>, plus --name and --upsert-key.`)
+        .option("--create <name>", "Push or web-intent feed only. Create a new table with this name — its columns derived from --schema-json, or the fixed reveal columns for --source rb2b — instead of binding an existing table.")
+        .option("--items-path <path>", "Push feed only. Dot path to an array of row objects in the delivered payload.")
+        .option("--event-id-path <path>", "Push feed only. Dot path to the event id. Defaults to event_id, eventId, id, or a payload hash.")
+        .option("--event-type-path <path>", "Push feed only. Dot path to the event type. Defaults to type or event.")
+        .option("--occurred-at-path <path>", "Push feed only. Dot path to the event timestamp.")
+        .option("--auth-mode <mode>", "Push feed only. secret (default: senders include the returned secret in x-oxygen-table-webhook-secret) or none.")
         .option("--tool-ids <csv>", "Comma-separated cascade of tool ids to try in order. Defaults to just --tool-id.")
         .option("--rows-path <path>", "Dot path to the row array in the provider response.")
         .option("--row-mapping-json <json-or-file>", "Row mapping JSON: table column key -> provider field path.")
         .option("--cursor-path <path>", "Dot path to the next-page cursor in the provider response.")
         .option("--cursor-request-key <key>", "Request key that receives the next cursor.")
         .option("--max-pages <n>", "Maximum provider pages per cycle. Defaults to 1.")
-        .option("--upsert-key <key>", "Column key rows are upserted on, so a cycle updates instead of duplicating.")
+        .option("--upsert-key <key>", "Column key rows are upserted on, so a cycle or a repeated delivery updates instead of duplicating.")
         .option("--name <name>", "Display name for the feed.")
         .option("--every <sugar>", CADENCE_FLAG_DESCRIPTION)
         .option("--max-credits <n>", "Credit ceiling PER sync cycle. Required with --approved to arm a cadence on a paid provider.")
@@ -6562,10 +7098,50 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--source-prompt <text-or-file>", "The prompt this feed was planned from, or a path to a prompt file.")
         .option("--approved", "Approve the recurring paid pull. Required with --every and --max-credits on a paid provider.")
         .option("--json", "Print a JSON envelope.")
-        .action((table, options) => handleAsyncAction("feeds bind", options, () => requestOxygen("/api/cli/tables/feeds", {
-        method: "POST",
-        body: readFeedBindBody(table, options),
-    }))))
+        .addHelpText("after", `
+Examples:
+  oxygen feeds bind signal-events --kind signal_search --tool-id blitzapi.job_search --request-json ./request.json --every daily@9 --max-credits 25 --approved
+  oxygen feeds bind --create "Inbound leads" --schema-json '{"type":"object","properties":{"email":{"type":"string"},"score":{"type":"number"}},"required":["email"],"additionalProperties":false}' --upsert-key email
+  oxygen feeds bind --source rb2b --create "Website visitors"
+`)
+        .action((table, options, command) => {
+        const webIntent = options.source !== undefined;
+        const push = options.schemaJson !== undefined;
+        // Pull usage errors keep commander's exact wording and path (stderr, exit 1),
+        // raised before any request exactly as the former requiredOption/<table> did.
+        if (!push && !webIntent)
+            assertPullFeedBindArguments(table, options, command);
+        return handleAsyncAction("feeds bind", options, async () => {
+            if (webIntent) {
+                const data = await requestOxygen("/api/cli/tables/feeds", {
+                    method: "POST",
+                    body: readFeedWebIntentBindBody(table, options),
+                });
+                // Nothing is withheld from stdout here (a web-intent feed has no
+                // secret and no address); the receipt exists so a human reads the
+                // table, the 0-credit cost, and what has to be true for rows to land.
+                if (!options.json)
+                    writeFeedWebIntentBindReceipt(data);
+                return data;
+            }
+            if (!push) {
+                return requestOxygen("/api/cli/tables/feeds", {
+                    method: "POST",
+                    body: readFeedBindBody(table, options),
+                });
+            }
+            const data = await requestOxygen("/api/cli/tables/feeds", {
+                method: "POST",
+                body: readFeedPushBindBody(table, options),
+            });
+            // Ahead of the payload, and only for a human: the secret is shown once,
+            // so it must not scroll away inside the JSON. A machine caller reads it
+            // off the envelope.
+            if (!options.json)
+                writeFeedPushBindReceipt(data);
+            return data;
+        });
+    }))
         .addCommand(new Command("pause")
         .description("Pause a feed: the cron stays armed but every cycle it fires is refused, so nothing is fetched and nothing is billed until you resume. Free.")
         .argument("<feed>", "Feed id or endpoint id.")
@@ -7976,13 +8552,15 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }));
     program
         .command("columns")
-        .description("Workspace table column commands. Ready-made templates (pricing pages, job posts, event pages, 10-Ks, website facts, market questions, text extraction, plus free 0-credit cleanups — company names, job titles, email type, text to list; person questions over an enriched LinkedIn profile and person appearances; company research questions — founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ and footprint, LinkedIn/Crunchbase/careers page lookups): `columns catalog`, then `columns add <table> --prompt-key <key> --input <name>=<column>`. Column choice and provider routing guide: the oxygen-gtm skill's enriching-and-researching.md (`oxygen skills install`). With --json parse stdout only: the envelope is stdout, and the spend and cost notes (`estimated N credits for a live run`) are stderr, so merging the streams breaks the JSON.")
+        .description("Workspace table column commands. Price first: `tools search --for-table <table>` lists every enrichment this table's columns support with its credit cost per row (0 credits). Ready-made templates (pricing pages, job posts, event pages, 10-Ks, website facts, market questions, text extraction, plus free 0-credit cleanups — company names, job titles, email type, text to list; person questions over an enriched LinkedIn profile and person appearances; company research questions — founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ and footprint, LinkedIn/Crunchbase/careers page lookups): `columns catalog`, then `columns add <table> --prompt-key <key> --input <name>=<column>`. Column choice and provider routing guide: the oxygen-gtm skill's enriching-and-researching.md (`oxygen skills install`). With --json parse stdout only: the envelope is stdout, and the spend and cost notes (`estimated N credits for a live run`) are stderr, so merging the streams breaks the JSON.")
         .addCommand(new Command("add")
         .description("Add a nullable column to a workspace table. Writes the definition only — this never runs the column and never spends credits; use `columns run` for that, with --dry-run first to see the cost. For a page, posting or filing the row already links to, or a company fact Oxygen already knows how to research (founders, parent company, funding, cloud provider, offers demos, industry, NAICS, HQ, a LinkedIn or Crunchbase page), pick a template from `columns catalog` (--prompt-key) instead of writing a prompt; or read a URL column with --kind research --research-url. The guide is the oxygen-gtm skill's enriching-and-researching.md. A formula column needs no run at all: it evaluates on read from its current inputs, so `tables query` shows its values immediately.")
         .argument("<table>", "Table id or slug.")
-        .option("--preset <preset>", "Add a pre-built column bundle instead of one column: `person_enrich` (one LinkedIn profile lookup, then headline, bio, location and followers for free), `company_enrich` (domain, LinkedIn page, headcount, industry and full profile, cascading across providers until one answers), or `domain_check` (1 credit/row for a live/redirect/parked/not_found/dead verdict on every domain, cached 30 days, plus a free label column to filter on). For a single cleaned or classified column, use a template from `columns catalog` instead — that is one column, not a bundle. Oxygen finds the identity column itself — override with --input. Creating the columns is free; run them afterwards, --dry-run first.")
+        .option("--preset <preset>", "Add a pre-built column bundle instead of one column, which is what --prompt-key adds: a preset writes SEVERAL columns at once and needs no --input on a table whose identity column it can find, while --prompt-key adds one template column and binds each input you name. Presets: `person_enrich` (one LinkedIn profile lookup, then first/last/full name, current company and its LinkedIn URL, job title, start date, education, school, headline, bio, location and followers as free formula columns; the person templates in `columns catalog --category people` all read its payload column), `company_enrich` (domain, LinkedIn page, headcount, industry and full profile, cascading across providers until one answers; binds to the person preset's current_company_linkedin_url automatically), `company_tech_stack` (the technologies a company runs, from its website and hiring, over the same cascade), `email_hashes` (SHA-256 and MD5 of each email for ad audiences, 0 credits), or `domain_check` (1 credit/row for a live/redirect/parked/not_found/dead verdict on every domain, cached 30 days, plus a free label column to filter on). For a single cleaned or classified column, use a template from `columns catalog` instead — that is one column, not a bundle. Oxygen finds the identity column itself — override with --input. Creating the columns is free; run them afterwards, --dry-run first.")
         .option("--input <slot=column...>", "Bind a preset or template input to an exact column, e.g. --input url=pricing_url with --prompt-key, or --input company_name=account --input domain=website with --preset. Repeatable. For a preset it is only needed when the automatic match is wrong or missing; for a template it names the column each declared input reads.", collectRepeatable, [])
-        .option("--capability <capability>", "Seed a ready-to-run enrichment column WITHOUT running it (0 credits): verify_email grades the address a row already holds \u2014 MillionVerifier first, catch-all domains escalate to BounceBan; work_email, mobile_phone and linkedin_url find a value the row is missing through the managed waterfall. Sets kind=enrichment and jsonb; label and key default from the capability. Preview cost with `enrich-column preview --capability <same>` and run later with `enrich-column run --approved --max-credits <n>`.")
+        .option("--preset-fields <fields>", "For --preset company_enrich: comma-separated field keys to create instead of the default bundle (see `oxygen find company --list-fields` for the catalog and per-row cost), e.g. --preset-fields headcount,industry,funding_stage,latest_funding_round,competitors,technologies,job_openings. Free derived fields read the profile the bundle already fetches; each lane-priced field adds its own cost to the run. On a table that already has the bundle, the new fields are added to the existing company enrichment column rather than a second one.")
+        .option("--check-technologies <names>", "For --preset company_enrich with the technology_check field: comma-separated technology names answered yes/no per row (e.g. hubspot,salesforce).")
+        .option("--capability <capability>", "Seed a ready-to-run enrichment column WITHOUT running it (0 credits): verify_email grades the address a row already holds \u2014 MillionVerifier first, catch-all domains escalate to BounceBan; work_email, personal_email, mobile_phone and linkedin_url find a value the row is missing through the managed waterfall (personal_email is the non-work mailbox, graded by MillionVerifier before it is written). Sets kind=enrichment and jsonb; label and key default from the capability. Preview cost with `enrich-column preview --capability <same>` and run later with `enrich-column run --approved --max-credits <n>`.")
         .option("--label <label>", "Display label for the new column. Required unless --prompt-key or --capability supplies a default title.")
         .option("--key <key>", "Optional stable column key. Defaults to a normalized label.")
         .option("--data-type <type>", "Column data type: text, numeric, boolean, jsonb, or timestamptz.")
@@ -8063,6 +8641,12 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                     presetBody.inputs = inputs;
                 if (options.key)
                     presetBody.payload_column = options.key;
+                const presetFields = readCsvOption(options.presetFields);
+                if (presetFields.length > 0)
+                    presetBody.fields = presetFields;
+                const checkTechnologies = readCsvOption(options.checkTechnologies);
+                if (checkTechnologies.length > 0)
+                    presetBody.check_technologies = checkTechnologies;
                 return requestOxygen("/api/cli/tables/columns", {
                     method: "POST",
                     body: presetBody,
@@ -8211,7 +8795,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("run")
-        .description("Run an executable AI, tool, formula, enrichment, bind, lookup, or local custom HTTP column for one row or a bounded batch. Paid server-side columns always run durably in the background. Bind create-mode (onNoMatch=create) needs --approved.")
+        .description("Run an executable AI, tool, formula, enrichment, bind, lookup, or custom HTTP column for one row or a bounded batch. Paid server-side columns always run durably in the background. Bind create-mode (onNoMatch=create) needs --approved.")
         .argument("<table>", "Table id or slug.")
         .argument("<column>", "Column id or key.")
         .option("--row-id <row_id>", "Workspace row id to run. Get one from `oxygen tables query <table> --limit 1 --json` — the field is `_row_id`, not `id`.")
@@ -8221,12 +8805,12 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--formula-values <mode>", "With --filter-json on a formula column, first refresh that selector with `columns run <table> <column> --force` (0 credits), then pass 'materialized'. The run filters the stored snapshot and persists this freshness acknowledgement.")
         .option("--force", "Run even when the target cell already has a value. Formula columns compute when read, so `tables query` shows their values without a run; a run skips rows that already store a value (existing_value), and --force refreshes them.")
         .option("--connection-id <connection_id>", "Optional provider integration connection id.")
-        .option("--background", "Create a durable background run for a free deterministic column. Paid AI/tool/enrichment/custom-HTTP server runs are always backgrounded.")
+        .option("--background", "Create a durable background run for a free deterministic column. Paid AI/tool/enrichment server runs are always backgrounded.")
         .option("--approved", "Confirm a paid durable run, or a bind create-mode run (onNoMatch=create), after inspecting a dry run or preview.")
         .option("--approved-effect-unknown", "With --row-id, allow rerunning a cell whose previous external write was dispatched but never confirmed. Verify the destination first: this can apply the same external effect twice.")
         .option("--max-credits <n>", "Maximum managed model/provider/web-grounding credits to reserve. BYOK covers the model call only; managed grounding still needs this ceiling.")
         .option("--max-concurrency <n>", "Maximum concurrent row items for a background run (1-250). Defaults to 250 for AI columns and 50 otherwise (160 for Firecrawl scrape columns).")
-        .option("--local", "Run a custom HTTP column in this CLI process so env-var secrets stay local.")
+        .option("--local", "Run a custom HTTP column in this CLI process, where {env:...} secrets read your own machine's environment. Without it the column runs in the background on Oxygen and the same reference resolves from this workspace's registered custom integration.")
         .option("--local-concurrency <n>", "Maximum concurrent custom HTTP requests for --local. Defaults to 3.")
         .option("--dry-run", "Preview resolved model, credit estimate, run-condition posture, and — for an AI column — the prompt rendered with one real row's values, without spending any credits.")
         .option("--json", "Print a JSON envelope.")
@@ -8572,7 +9156,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("catalog")
-        .description("List the column templates you can add with `columns add <table> --prompt-key <key>`: the extract templates (pricing-page, job-posting, event, 10-K, website-fact, market and text extractors) and the company research questions (founders, parent company, subsidiaries, funding rounds, market cap, cloud provider, is SaaS, offers demos, industry, NAICS, HQ / states / cities, competitors, LinkedIn / Crunchbase / Glassdoor / careers page lookups) and the person templates (--category people: skill set, grad school, location, job fit and current company read from the person_enrich payload for 15 credits; events, keynotes, podcasts and GitHub profile searched by name), each with the input it reads (bind it with --input <name>=<column_key>), the providers behind it, the answer fields, and the credits per row. Read-only and free.")
+        .description("List the column templates you can add with `columns add <table> --prompt-key <key>`: the extract templates (pricing-page, job-posting, event, 10-K, website-fact, market and text extractors) and the company research questions (founders, parent company, subsidiaries, funding rounds, market cap, cloud provider, is SaaS, offers demos, industry, NAICS, HQ / states / cities, competitors, LinkedIn / Crunchbase / Glassdoor / careers page lookups) and the person templates (--category people: skill set, grad school, location, job fit and current company read from the person_enrich payload for 15 credits; events, keynotes, podcasts and GitHub profile searched by name), each with the input it reads (bind it with --input <name>=<column_key>), the providers behind it, the answer fields, and the credits per row. Read-only and free. Tool-backed columns that read a page or call a provider — e.g. Website contacts (emails and phones from each row's site) — are found with `oxygen tools search <words>`, not here. Provider waterfalls and enrichment bundles are a different list with their own per-row prices: `oxygen enrichment catalog`.")
         .option("--category <category>", "Only templates in one picker section: extract (page and text extraction), normalize, organize, summarize (free cleanups and classifications), people (person questions and appearances) or company (company research questions); comma-separate to combine (extract,people). The outreach prompts sit under copy, scoring, qa, research.")
         .option("--family <family>", "Only one family. Extract: pricing, job_posting, events, filings, site_facts, market, portfolio, text_extraction. Cleanups: company, person, email, lists, classification. Company: web_presence, corporate_structure, funding, footprint, business_model, tech, market. People: profile, appearances.")
         .option("--kind <kind>", "Only one column kind: research (reads the web or a page, answer with sources), search (a managed web search whose cell is a page URL or the result list, fixed price), ai (reads row text), or formula (free).")
@@ -9060,7 +9644,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             method: "POST",
             body: {
                 table,
-                plan: parseJsonObject(readFileIfPresent(options.plan)),
+                // Accepts the `search plan --json` envelope as-is, like the
+                // companies/people/signals runs do: the inner `data` is the plan.
+                plan: readSearchPlanJson(options.plan),
                 request: parseJsonObject(options.requestJson),
                 ...(readOption(options.route) ? { route_id: readOption(options.route) } : {}),
                 ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
@@ -9137,19 +9723,24 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("search")
         .description("Plan, dry-run, or queue provider-backed company search.")
         .addCommand(new Command("filters")
-        .description("List Company Search filter fields and options without a provider call.")
+        .description("List Company Search filter fields and options without a provider call, including every enum field's full accepted-value list. --source hiring lists the Job postings filters instead (job.* and company.*).")
+        .option("--source <source>", "company_search (default) or hiring: live job postings for the roles you name, one row per posting with a link to it.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("companies search filters", options, () => requestOxygen("/api/cli/companies/search/preview"));
+        await handleAsyncAction("companies search filters", options, () => requestOxygen(`/api/cli/companies/search/preview${readCompanySourceQuery(options.source)}`));
     }))
         .addCommand(new Command("preview")
-        .description("Preview up to 50 companies free, using native filters from companies search filters.")
+        .description("Preview up to 50 rows free, using native filters from companies search filters. With --source hiring the sample is the open roles matching job.title, one row per posting, and total_results is the exact number of matching postings.")
         .requiredOption("--filters-json <json-or-file>", 'Nested native filters as JSON or @file/path, e.g. {"employee_count":{"min":10}}; {} searches all.')
+        .option("--source <source>", "company_search (default) or hiring. Filters for hiring nest under job and company, e.g. {\"job\":{\"title\":{\"include\":[\"Account Executive\"]}}}.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("companies search preview", options, () => requestOxygen("/api/cli/companies/search/preview", {
             method: "POST",
-            body: { filters: parseJsonObject(readFileIfPresent(options.filtersJson)) },
+            body: {
+                filters: parseJsonObject(readFileIfPresent(options.filtersJson)),
+                ...(readCompanySearchSource(options.source) !== "company_search" ? { source: readCompanySearchSource(options.source) } : {}),
+            },
         }));
     }))
         .addCommand(new Command("plan")
@@ -9181,8 +9772,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }))
         .addCommand(new Command("run")
         .description("Return a dry-run request or queue a live company-search ingestion run.")
-        .option("--source <source>", "Use company_search with --source-filters-json instead of a prompt or plan.")
-        .option("--source-filters-json <json-or-file>", 'Same nested filters as the free preview, e.g. {"employee_count":{"min":10}}; use with --source company_search.')
+        .option("--source <source>", "Use company_search or hiring with --source-filters-json instead of a prompt or plan. hiring sources the live job postings for the roles you name, one row per posting (up to 5,000 per search), each with its posting URL, date and hiring company.")
+        .option("--source-filters-json <json-or-file>", 'Same nested filters as the free preview, e.g. {"employee_count":{"min":10}} or, with --source hiring, {"job":{"title":{"include":["Account Executive"]}}}.')
+        .option("--table-name <name>", "Name the table this run creates. Ignored when --table names an existing table, which must already exist.")
         .argument("[prompt]", "Prompt text or @file (same as --prompt). The --prompt flag wins if both are given.")
         .option("--prompt <text-or-file>", "Company-search prompt, or a path to a prompt file.")
         .option("--plan-json <json-or-file>", "Plan JSON returned by companies search plan, or a path to a JSON file.")
@@ -9192,9 +9784,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--project <project>", "Folder (project) id or slug the created table lands in. Ignored with --table. Defaults to the workspace default folder.")
         .option("--upsert-key <column>", "Column key used for live upsert. Must match the plan upsert key, usually domain.")
         .option("--mode <mode>", "dry_run or live. Defaults to dry_run.")
-        .option("--max-pages <n>", "Maximum provider pages to ingest. Defaults to the route estimate.")
+        .option("--max-pages <n>", "Maximum provider pages to ingest. Defaults to the route estimate, and is itself capped by --target-count: asking for more pages than that many rows needs cannot add rows.")
         .option("--max-credits <n>", "Required credit ceiling for live runs.")
-        .option("--target-count <n>", "Desired company count when planning from --prompt. Single-plan ceiling 50,000.")
+        .option("--target-count <n>", "How many rows to source. Defaults to 50 — one page — so raise it to import more than the free sample, using the preview's total_results as the real ceiling. It bounds pagination: --max-pages can never exceed the pages this count needs, and a run that stops because of it reports stopped_by row_target.")
         .option("--source-intent <intent>", "Override detected intent when planning from --prompt.")
         .option("--filters-json <json-or-file>", "CompanySearchFilters JSON inline or a @file/path when planning from --prompt; wins over individual flags per top-level filter path.")
         .option("--industries <csv>", "Comma-separated industries to include when planning from --prompt.")
@@ -9222,7 +9814,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("preview")
         .description("Inspect missing company fields, provider routing, and credit estimates without provider calls.")
         .argument("<table>", "Table id or slug.")
-        .option("--missing-fields <fields>", "Comma-separated fields to fill: domain,linkedin_url,headcount,industry,funding,technologies,hiring_signals,company_profile.")
+        .option("--missing-fields <fields>", "Comma-separated fields to fill; accepts every key `oxygen find company --list-fields` prints, not just the identity set. Derived fields (description, founded_year, hq_country, funding_stage, latest_funding_round, investors, job_openings, parent_company, subsidiaries) are read from a payload the run already fetches and add no provider lane of their own.")
         .option("--providers <providers>", "Comma-separated provider order pool. Defaults to scraper,blitzapi,crustdata,ai_ark,prospeo,leadmagic.")
         .option("--all", "Preview all rows.")
         .option("--limit <n>", "Preview a limited row scope.")
@@ -9262,6 +9854,22 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("People and contact prospecting workflows.")
         .addCommand(new Command("search")
         .description("Plan, dry-run, or queue provider-backed people/contact search.")
+        .addCommand(new Command("filters")
+        .description("List Find people filter fields and options without a provider call: people.* (title, level, function, location, education) and company.* (industry, headcount, location, funding, up to 50 company LinkedIn URLs). Every enum field ships its full accepted-value list, so no value has to be guessed. Shape rule: only a field whose own key ends in .include or .exclude takes {include, exclude} — every other list field takes the strings directly. To search the companies in a table you already have, rather than pasting their URLs here, use people search plan|run --from-table <table> --linkedin-url-column <key>, which searches each company and writes a company relation back.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("people search filters", options, () => requestOxygen("/api/cli/people/search/preview"));
+    }))
+        .addCommand(new Command("preview")
+        .description("Preview up to 50 people free, using native filters from people search filters. Then people search run --source people_search --source-filters-json <same filters> for a quoted, approved table fill. Scoping to companies you already keep in a table is people search run --from-table instead — one search per company, so it costs per company but covers each one.")
+        .requiredOption("--filters-json <json-or-file>", 'Nested native filters as JSON or @file/path, e.g. {"people":{"job_title":{"include":["VP Sales"]}},"company":{"linkedin_url":["https://linkedin.com/company/acme"]}}; {} searches all.')
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("people search preview", options, () => requestOxygen("/api/cli/people/search/preview", {
+            method: "POST",
+            body: { filters: parseJsonObject(readFileIfPresent(options.filtersJson)) },
+        }));
+    }))
         .addCommand(new Command("plan")
         .description("Compile a people-search prompt and optional typed persona filters into ordered provider routes without provider calls.")
         .option("--prompt <text-or-file>", "People-search prompt, or a path to a prompt file. Required unless --from-table names the companies to source employees from.")
@@ -9302,6 +9910,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }))
         .addCommand(new Command("run")
         .description("Return a dry-run request or queue a live people-search ingestion run. Upsert dedup is on linkedin_url.")
+        .option("--source <source>", "Use people_search with --source-filters-json instead of a prompt or plan: the same filters as people search preview, no prompt needed.")
+        .option("--source-filters-json <json-or-file>", 'Same nested filters as the free preview, e.g. {"people":{"job_title":{"include":["VP Sales"]}}}; use with --source people_search.')
+        .option("--table-name <name>", "Name the table this run creates. Ignored when --table names an existing table, which must already exist.")
         .option("--prompt <text-or-file>", "People-search prompt, or a path to a prompt file.")
         .option("--plan-json <json-or-file>", "Plan JSON returned by people search plan, or a path to a JSON file.")
         .option("--route-id <id>", "Route id from the plan to execute.")
@@ -9458,7 +10069,11 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .description("Plan and managed credit commands. Spend splits into FLEXIBLE (ad-hoc: enrichment, AI, automation — drawn from your free-to-spend balance) and FIXED recurring per-resource monthly commitments blocked out of it; see `billing commitments`. THREE CLOCKS, deliberately different: the CREDIT CYCLE that `billing allowance` reports against (your plan's monthly grant window); each resource's own COMMITMENT RENEWAL, anchored to the day you connected it, so `billing commitments --json` next_due_at rarely matches the cycle end; and your SUBSCRIPTION PERIOD in `billing balance` (annual plans span many credit cycles). A number from one clock will not reconcile against another. Failed-payment grace, suspension, and recovery: https://oxygen-agent.com/docs/safety/billing.")
         .addCommand(new Command("change")
         .description("Preview an upgrade or downgrade and return a Stripe confirmation link. Nothing changes until confirmed in Stripe.")
-        .requiredOption("--to <tier>", "Target plan: starter, pro, or team.")
+        .requiredOption("--to <plan>", 
+    // Derived from the catalog, never retyped: this help text is the only
+    // place a customer's agent learns which plans exist, and it named
+    // three retired ones for as long as it was a literal.
+    `Target plan: ${PURCHASABLE_PLAN_KEYS.join(", ")}.`)
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing change", options, () => requestOxygen("/api/cli/billing/change", {
@@ -9647,9 +10262,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }));
     }))
         .addCommand(new Command("topup")
-        .description("Buy a custom amount of on-demand credits at $1.25 per 1,000. Run without an amount to inspect the allowed range; checkout happens in Stripe and purchased credits never expire.")
+        .description("Buy a custom amount of on-demand credits at $1.25 per 100. Run without an amount to inspect the allowed range; checkout happens in Stripe and purchased credits never expire.")
         .argument("[pack]", "Legacy pack alias in USD: 10, 25, 100, or 250.")
-        .option("--credits <n>", "Credits to buy (8,000-1,000,000 in 1,000-credit increments).")
+        .option("--credits <n>", "Credits to buy (800-100,000 in 100-credit increments).")
         .option("--json", "Print a JSON envelope.")
         .action(async (pack, options) => {
         const credits = readOption(options.credits);
@@ -10999,13 +11614,13 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }));
     program
         .command("tools")
-        .description("Tool catalog commands.")
+        .description("The priced catalog: every provider operation and every OXYGEN column (enrichment bundles, waterfalls, templates, Functions) with its credit cost per row. Start with `tools search --for-table <table>` to see what a table's own columns can be enriched with and what each costs, before adding anything.")
         .addCommand(new Command("search")
-        .description("Search a bounded, compact provider-operation catalog; hydrate one result with tools get. A response listing partial_sources means an optional catalog source timed out and totals may be understated — rerun for the complete catalog.")
+        .description("Search the priced catalog (0 credits): provider operations in `tools`, and OXYGEN's own columns in `native_columns` (enrichment bundles, waterfalls, templates, Functions), each with `price_label`, `estimated_credits_per_row`, `pricing_kind` and the exact `cli_add` command. With --for-table <table> it reads that table's columns and returns `suggestions`: the enrichments those columns already support, priced per row. Hydrate one provider operation with tools get. A response listing partial_sources means an optional catalog source timed out and totals may be understated — rerun for the complete catalog.")
         .argument("[query]", "Search text.")
         .option("--verbosity <verbosity>", "minimal, summary, or full. Defaults to minimal; hydrate one result with tools get.")
         .option("--terse", "Alias for --verbosity minimal.")
-        .option("--all", "Return the complete matching catalog. Explicit because the default is bounded to 10.")
+        .option("--all", "Return the complete matching catalog — with no query that is every provider operation (7,000+ rows). Explicit because the default is bounded to 10; with --for-table the table-scoped answer is `suggestions`, which --all does not change.")
         .option("--only-runnable", "Only return tools runnable by the active organization.")
         .option("--workflow-eligible", "Only return tools a hosted workflow step may call, each annotated with the canonical `workflow_effect` its manifest step must declare. This is a narrower set than the table-column catalog — use it when authoring a workflow manifest so lint cannot reject a tool at apply time.")
         .option("--no-access-check", "Skip per-tool availability checks for a fast complete-catalog listing. Tools are returned without availability info; pair with --terse for discovery sweeps.")
@@ -11014,11 +11629,21 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--provider <provider>", "Filter to one exact provider id, such as blitzapi.")
         .option("--limit <n>", "Maximum number of tools to return. Capped at 100.")
         .option("--providers", "Also return a per-vendor summary (provider id, display name, tool count) alongside the tools.")
+        .option("--for-table <table>", "Table id or slug. Prices Oxygen's own column kinds, presets and waterfalls (native_columns) for that table's columns and lists deterministic suggestions first — what you can enrich here and what each costs per row, before adding anything. `suggestions` (cross-referenced into native_columns) is the table-scoped answer; `tools` stays the general provider catalog, so leave --all off unless you want every provider operation.")
+        .option("--favorites", "Only the catalog entries you favourited for this workspace (see tools favorite).")
+        .option("--table-runnable", "Only tools a table column can run.")
         .option("--json", "Print a JSON envelope.")
         .action(async (query, options) => {
         await handleAsyncAction("tools search", options, async () => {
             const params = new URLSearchParams();
             params.set("query", query ?? "");
+            const forTable = readOption(options.forTable);
+            if (forTable)
+                params.set("for_table", forTable);
+            if (options.favorites)
+                params.set("favorites", "true");
+            if (options.tableRunnable)
+                params.set("table_runnable", "true");
             const verbosity = options.terse ? "minimal" : readOption(options.verbosity);
             if (verbosity)
                 params.set("verbosity", verbosity);
@@ -11053,6 +11678,32 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--json", "Print a JSON envelope.")
         .action(async (toolId, options) => {
         await handleAsyncAction("tools get", options, () => requestOxygen(`/api/cli/tools/${encodeURIComponent(toolId)}`));
+    }))
+        .addCommand(new Command("favorite")
+        .description("Favourite one column-catalog entry for this workspace: a native column (find_email, preset:person_enrich, prompt:icp_fit_score_v1) or a vendor tool (tool:<tool_id>). Favourites lead every table's + Add column panel and `tools search --favorites`.")
+        .argument("<entry_id>", "Catalog entry id, e.g. find_email, preset:person_enrich, prompt:<key>, tool:<tool_id>.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (entryId, options) => {
+        await handleAsyncAction("tools favorite", options, () => requestOxygen("/api/cli/tools/favorites", {
+            method: "POST",
+            body: { entry_id: entryId, favorite: true },
+        }));
+    }))
+        .addCommand(new Command("unfavorite")
+        .description("Remove one column-catalog entry from your favourites for this workspace.")
+        .argument("<entry_id>", "Catalog entry id, as listed by tools favorites.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (entryId, options) => {
+        await handleAsyncAction("tools unfavorite", options, () => requestOxygen("/api/cli/tools/favorites", {
+            method: "POST",
+            body: { entry_id: entryId, favorite: false },
+        }));
+    }))
+        .addCommand(new Command("favorites")
+        .description("List your favourite column-catalog entries for this workspace, with each native entry's per-row price.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("tools favorites", options, () => requestOxygen("/api/cli/tools/favorites"));
     }))
         .addCommand(new Command("enums")
         .description("Provider enum catalogs for fields that accept normalized values.")
@@ -11117,28 +11768,32 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         // 24.94", so an integer reader would refuse the very command the CLI
         // just told the operator to run.
         const maxCredits = readNonNegativeNumber(options.maxCredits);
-        await handleAsyncAction("tools run", options, () => requestOxygen("/api/cli/tools/run", {
-            method: "POST",
-            body: {
-                tool_id: toolId,
-                input: parseJsonObject(options.inputJson),
-                ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
-                ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
-                ...(readOption(options.org) ? { org_id: readOption(options.org) } : {}),
-                ...(readOption(options.orgId) ? { org_id: readOption(options.orgId) } : {}),
-                ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
-                ...(readOption(options.fields) ? { fields: readCsvOption(options.fields) } : {}),
-                ...(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 } : {}),
-            },
-        }));
+        await handleAsyncAction("tools run", options, async () => {
+            const data = await requestOxygen("/api/cli/tools/run", {
+                method: "POST",
+                body: {
+                    tool_id: toolId,
+                    input: parseJsonObject(options.inputJson),
+                    ...(readOption(options.mode) ? { mode: readOption(options.mode) } : {}),
+                    ...(readOption(options.credentialMode) ? { credential_mode: readOption(options.credentialMode) } : {}),
+                    ...(readOption(options.org) ? { org_id: readOption(options.org) } : {}),
+                    ...(readOption(options.orgId) ? { org_id: readOption(options.orgId) } : {}),
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(readOption(options.fields) ? { fields: readCsvOption(options.fields) } : {}),
+                    ...(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 } : {}),
+                },
+            });
+            writeToolRunBlockedNotice(data);
+            return data;
+        });
     }));
     program
         .command("enrich-column")
-        .description("High-level table enrichment helpers.")
+        .description("High-level table enrichment helpers. To see every enrichment a table's columns support, with per-row prices, before choosing one, run `tools search --for-table <table>` (0 credits).")
         .addCommand(new Command("preview")
         .description("Preflight an enrichment column without provider calls or credit usage.")
         .argument("<table>", "Table id or slug.")
@@ -11151,7 +11806,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--company-domain-column <column>", "Column key or id containing the company domain for work_email. Pair with full-name/first+last for name+company providers.")
         .option("--company-name-column <column>", "Column key or id containing the company name for work_email when no domain is available.")
         .option("--company-linkedin-url-column <column>", "Column key or id containing the company's LinkedIn URL for company identity fallback.")
-        .option("--capability <capability>", "What to run: mobile_phone, work_email, linkedin_url (find a missing value), or verify_email (grade an email the row already has). Defaults to mobile_phone.")
+        .option("--capability <capability>", "What to run: mobile_phone, work_email, personal_email, linkedin_url (find a missing value), or verify_email (grade an email the row already has). Defaults to mobile_phone.")
         .option("--target-column <column>", "Target enrichment column key. Defaults to the capability payload column.")
         .option("--on-existing-manual-column <mode>", "How to handle an existing manual target: error, write_if_empty, or create_enrichment_column.")
         .option("--provider-order <providers>", "Comma-separated provider order. Overrides the default cost-aware waterfall profile.")
@@ -11186,7 +11841,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--company-name-column <column>", "Column key or id containing the company name for work_email when no domain is available.")
         .option("--company-linkedin-url-column <column>", "Column key or id containing the company's LinkedIn URL for company identity fallback.")
         .requiredOption("--max-credits <credits>", "Required credit ceiling for the queued run.")
-        .option("--capability <capability>", "What to run: mobile_phone, work_email, linkedin_url (find a missing value), or verify_email (grade an email the row already has). Defaults to mobile_phone.")
+        .option("--capability <capability>", "What to run: mobile_phone, work_email, personal_email, linkedin_url (find a missing value), or verify_email (grade an email the row already has). Defaults to mobile_phone.")
         .option("--target-column <column>", "Target enrichment column key. Defaults to the capability payload column.")
         .option("--on-existing-manual-column <mode>", "How to handle an existing manual target: error, write_if_empty, or create_enrichment_column.")
         .option("--provider-order <providers>", "Comma-separated provider order. Overrides the default cost-aware waterfall profile.")
@@ -11234,6 +11889,19 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .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("personal-email")
+        .description("Find a person's personal (non-work) email — for ad-audience uploads, recruiting, or founder outreach — via a cost-ordered multi-provider waterfall that bills only on a hit and grades the address with MillionVerifier before returning it. Every default lane keys on a LinkedIn URL; ContactOut also accepts a known email or full name + company. dry_run previews the chain and its price for free.")
+        .option("--linkedin-url <url>", "Person LinkedIn profile URL (strongest signal; every default lane accepts it).")
+        .option("--email <email>", "Known email as an identity fallback (ContactOut lane).")
+        .option("--full-name <name>", "Person full name (with a company domain or name; ContactOut lane).")
+        .option("--company-domain <domain>", "Company apex domain, e.g. acme.com.")
+        .option("--company-name <name>", "Company name.")
+        .option("--mode <mode>", "dry_run (default) previews the plan and spends nothing; live spends credits and returns the answer.")
+        .option("--max-credits <credits>", "Spend ceiling. Required for --mode live. Run the free dry_run first: it returns estimate.recommended_max_credits, the ceiling that lets the WHOLE resolved waterfall run, plus estimate.min_credits and a per-leg breakdown. A lower ceiling does NOT stop the run: each lane priced above what is left of it is refused on its own (spend_cap_too_low) and the waterfall advances, so a cheaper lane further down the chain can still run and bill.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("find personal-email", options, () => requestOxygen("/api/cli/find/run", { method: "POST", body: buildFindBody("personal_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.")
@@ -11261,13 +11929,33 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .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("person")
+        .description("Enrich one person from a LinkedIn URL, a LinkedIn public id, a Sales Navigator link, or an email / name + company: one managed profile lookup returns the profile block — first, last and full name, current company and its LinkedIn URL, job title, job start date, education and school, headline, bio, location and follower count — the same fields the person_enrich table preset extracts for free. An email or name is first resolved to the profile through the LinkedIn URL waterfall (priced as an identity prerequisite). A Sales Navigator link or member id resolves only on the workspace's own HarvestAPI key. dry_run previews the lookup and its price for free.")
+        .option("--linkedin-url <url>", "Person LinkedIn profile URL (linkedin.com/in/<handle>).")
+        .option("--linkedin-id <id>", "LinkedIn public identifier (the part after /in/), or an ACoAA/ACwAA member id (BYOK HarvestAPI only).")
+        .option("--sales-navigator-url <url>", "Sales Navigator lead or people link; resolved on the workspace's own HarvestAPI key.")
+        .option("--email <email>", "Known email; resolved to the profile through the LinkedIn URL waterfall first.")
+        .option("--full-name <name>", "Person full name; with --company-domain or --company-name, resolved through the LinkedIn URL waterfall first.")
+        .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("--include-raw", "Also return the provider's raw profile payload (profile_raw) for fields the profile block does not carry.")
+        .option("--mode <mode>", "dry_run (default) previews the plan and spends nothing; live spends credits and returns the profile.")
+        .option("--max-credits <credits>", "Spend ceiling. Required for --mode live. Run the free dry_run first: estimate.recommended_max_credits funds the profile lookup plus, for an email or name input, every lane of the LinkedIn URL waterfall that resolves it.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("find person", options, () => requestOxygen("/api/cli/find/run", { method: "POST", body: buildFindBody("person", options) }));
     }))
         .addCommand(new Command("company")
-        .description("Enrich a company (domain/linkedin/headcount/industry/funding/tech/hiring/profile) via a waterfall.")
+        .description("Enrich a company via a waterfall: identity, firmographics, structured funding, competitors, corporate structure, acquisitions, news, job openings, tech stack, web-presence URLs. `--list-fields` prints the catalog with per-field cost.")
         .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("--fields <fields>", "Comma-separated field keys from --list-fields (e.g. headcount,industry,funding_stage,latest_funding_round,competitors,technologies,job_openings). Defaults to domain,linkedin_url,headcount,industry,description,founded_year,hq_country — the identity plus everything one profile lookup answers for free. Unknown keys are refused, never silently dropped.")
+        .option("--list-fields", "Print the field catalog (category, description, provider count, per-row credits: free / fixed / ~estimated) and exit. Needs no identity; spends nothing.")
+        .option("--check-technologies <names>", "Comma-separated technology names for the technology_check field, answered yes/no against the detected stack (e.g. hubspot,salesforce).")
         .option("--mode <mode>", "dry_run (default) previews the plan and spends nothing; live spends credits and returns the answer.")
         .option("--max-credits <credits>", "Spend ceiling. Required for --mode live; 0 runs only the zero-credit lanes (the priced lanes are skipped as credit_ceiling_reached). Run the free dry_run first: it returns estimate.recommended_max_credits, the ceiling that funds every lane in the plan, and estimate.min_credits, what the plan costs if each field is answered by its first lane.")
         .option("--json", "Print a JSON envelope.")
@@ -11298,7 +11986,32 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
     }));
     program
         .command("enrichment")
-        .description("High-level enrichment column definition helpers.")
+        .description("The enrichment catalogue: name the DATA (work email, phone, headcount, funding, tech stack, decision makers), see its status, expected vs up-to credits per row, coverage and the exact add command — never pick a provider by hand.")
+        .addCommand(new Command("catalog")
+        .description("Name the DATA, not the provider: list every data type you can ask a table to fill (person profile, work email, phone, headcount, funding, tech stack, hiring, competitors, news, decision makers, signals ...) as `intents`, each with its status (default | selectable | no_default | coming_soon | rejected), the inputs it needs, the fields it fills, region coverage bands (vendor claims until measured), the provider order behind it as metadata, a per-row credit estimate (expected on measured-or-assumed hit rates, plus the up-to ceiling) and the exact add command on CLI, MCP and web. `entries` keeps the column presets, capabilities and recipes. Read this before `columns add --preset` or `--capability`; 0 credits. (Extract column templates have their own `columns catalog`.)")
+        .option("--intent <id>", "One intent id, e.g. find_work_email, enrich_company:funding, people_search:account_contacts.")
+        .option("--group <group>", "Filter intents to one group: person, contact, company, decision_maker, or signal.")
+        .option("--region <region>", "Show the coverage band for one region and hide rows the vendors exclude there: US, UK, DACH, EU_REST, or APAC.")
+        .option("--status <status>", "Filter intents to one status: default, selectable, no_default, coming_soon, or rejected.")
+        .option("--category <category>", "Filter the column entries to one category: Person, Contact, Company, or Ads.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("enrichment catalog", options, async () => {
+            const params = new URLSearchParams();
+            for (const key of ["intent", "group", "region", "status"]) {
+                const value = readOption(options[key]);
+                if (value)
+                    params.set(key, value);
+            }
+            const query = params.toString();
+            const envelope = await requestOxygen(`/api/cli/enrichment/catalog${query ? `?${query}` : ""}`, { method: "GET" });
+            const wanted = readOption(options.category)?.toLowerCase();
+            if (!wanted || !Array.isArray(envelope.entries))
+                return envelope;
+            const entries = envelope.entries.filter((entry) => String(entry.category ?? "").toLowerCase() === wanted);
+            return { ...envelope, entries, category: wanted };
+        });
+    }))
         .addCommand(new Command("apply-default-cascade")
         .description("Patch an existing enrichment column to the server-side default provider cascade for its intent.")
         .argument("<table>", "Table id or slug.")
@@ -12822,7 +13535,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("get")
-        .description("Get one conversation with its full message thread. <conversation> accepts a conversation id, Unipile chat id, or (email) Zapbox thread id, and is resolved on any channel by default (email first, then LinkedIn/WhatsApp).")
+        .description("Get one conversation with its full message thread. <conversation> accepts a conversation id, Unipile chat id, or (email) Zapbox thread id, and is resolved on any channel by default (email first, then LinkedIn/WhatsApp). Opening a WhatsApp thread may fetch provider history and merge provider-confirmed phone/contact identities in the local mirror. This uses no Oxygen credits and sends no message; old conversation references remain usable. For stored-only inspection, use messages query.")
         .argument("<conversation>", "Conversation id, Unipile chat id, or Zapbox thread id.")
         .option("--channel <channel>", "Inbox channel: all (default, resolves the id on any channel), email, linkedin, or whatsapp.")
         .option("--message-limit <n>", "Maximum messages to return (1-500). Defaults to 100.")
@@ -13324,7 +14037,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))));
     program.addCommand(new Command("messages")
-        .description("Cross-channel message corpus: every individual email + LinkedIn + WhatsApp message as one searchable stream (Postgres full-text search over bodies, keyset paginated by recency), plus reply-rate/campaign analytics. Message-level, unlike inbox (conversation-level triage).")
+        .description("Cross-channel message corpus: every individual email + LinkedIn + WhatsApp message as one searchable stream (Postgres full-text search over bodies, keyset paginated by recency), plus INBOX-WIDE conversation analytics. NOT campaign performance: for per-channel campaign reply rates use `oxygen sequences analytics`. Message-level, unlike inbox (conversation-level triage).")
         .addCommand(new Command("query")
         .description("Query messages across channels newest first, or relevance-ranked when -q is set. --channel all merges email + LinkedIn + WhatsApp (narrow with --channels); a campaign filter (--sequence-id) restricts to email. Filter by direction, account, contact, status, and date range. Scope: the Messages store (Unibox conversations, every native email since v1.927.0 linked to its campaign; earlier sends without a provider thread id are not). The complete send ledger of a sequence is `sequences events --kind sent`; its counts are `sequences stats`.")
         .option("-q, --query <text>", "Full-text search over message bodies (relevance-ranked).")
@@ -13370,7 +14083,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("stats")
-        .description("Unibox/Message-ledger analytics: outbound/inbound totals, heuristic reply rate by channel + campaign, status breakdowns, response-time percentiles, top counterpart domains, and winning openers. Messages with no sequence id remain outside byCampaign. For native Sequence sent/replied/bounced attribution by mailbox and sending domain, use `oxygen sequences analytics`. Scope with --sequence-id, --channel, and a date range. Defaults to the last 30 days; pass --all-time for full history.")
+        .description("INBOX-WIDE message-ledger analytics over the WHOLE corpus, not your campaigns: outbound/inbound totals, a conversation-level reply rate (has-inbound over has-outbound) by channel, status breakdowns, response-time percentiles, top counterpart domains, and winning openers. It counts every conversation in the workspace, including mail no campaign sent, so its reply rate is NOT your campaign reply rate — for that, and for per-channel campaign performance, use `oxygen sequences analytics`. byCampaign is email-only because direct-message conversations carry no campaign link; an empty list there is inaccessible, not absence. Scope with --sequence-id, --channel, and a date range. Defaults to the last 30 days; pass --all-time for full history.")
         .option("--sequence-id <ids>", "Comma-separated campaign (sequence) ids to scope to.")
         .option("--channel <channel>", "Channel: all (default), email, linkedin, or whatsapp.")
         .option("--since <iso>", "Only messages sent at or after this ISO timestamp. Defaults to 30 days ago.")
@@ -13401,12 +14114,13 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("list")
         .description("List sequences with persisted launch status kept separate from current operational state. Fleet counts report marked-active versus operationally-live (active with nonterminal work), and rows explain flowing, paced, blocked, degraded, drained, or empty work without SQL. --stats joins each row's LIFETIME funnel.")
         .option("--status <status>", "Filter by status: draft, active, paused, or archived.")
-        .addOption(new Option("--operational-state <state>", "Filter by current work state; fleet counts remain unfiltered: empty, drained, blocked, degraded, flowing, or paced.").choices(["empty", "drained", "blocked", "degraded", "flowing", "paced"]))
+        .addOption(new Option("--operational-state <state>", "Filter by current work state; fleet counts remain unfiltered: empty, drained, never_started (enrolled leads, never launched), blocked, degraded, flowing, or paced.").choices(["empty", "drained", "never_started", "blocked", "degraded", "flowing", "paced"]))
+        .addOption(new Option("--channel <channel>", "Only sequences carrying this channel.").choices(["email", "linkedin", "whatsapp"]))
         .option("--tag <tag>", "Only sequences carrying this workspace tag (see `oxygen tags list`).")
         .option("--stats", "Attach lifetime stats per sequence (a stats pass per row — slower on large workspaces).")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleSequenceReadAction("sequences list", options, () => {
+        await handleReadActionWithLens("sequences list", options, () => {
             const params = new URLSearchParams();
             const status = readOption(options.status);
             if (status)
@@ -13414,6 +14128,9 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const operationalState = readOption(options.operationalState);
             if (operationalState)
                 params.set("operational_state", operationalState);
+            const channel = readOption(options.channel);
+            if (channel)
+                params.set("channel", channel);
             const tag = readOption(options.tag);
             if (tag)
                 params.set("tag", tag);
@@ -13644,7 +14361,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--sequence <id-or-slug>", "Limit analytics to one sequence.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleSequenceReadAction("sequences analytics", options, () => {
+        await handleReadActionWithLens("sequences analytics", options, () => {
             const params = new URLSearchParams();
             const range = readOption(options.range);
             const from = readOption(options.from);
@@ -13671,9 +14388,11 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live — WhatsApp via Unipile is unofficial WhatsApp Web, so cold-initiating is an explicit ban-risk opt-in.")
         .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile).")
         .option("--senders <ids>", "Comma-separated LinkedIn or WhatsApp sender account ids (or connection / Unipile ids; `linkedin senders` / `whatsapp accounts` list them). Optional at create; enroll and start require at least one when the journey has LinkedIn or WhatsApp steps (attach later with `sequences update --senders`).")
-        .option("--table <id>", "Source table id whose rows supply {{column}} template values.")
+        .option("--table <id>", "Source table id or slug whose rows supply {{column}} template values.")
+        .option("--from-table <id>", "Alias of --table: the source table id or slug this sequence draws its leads and {{column}} values from.")
+        .option("--enroll", "After creating the sequence, immediately enroll every row of the bound table (same as running `sequences enroll --from-table` next). Requires --table/--from-table. Enrolling spends no credits and sends nothing.")
         .option("--url-column <key>", "Column key holding each lead's LinkedIn URL/provider id.")
-        .option("--email-provider <provider>", "Email provider for the email track. Only 'instantly' is supported.")
+        .option("--email-provider <provider>", "Email track provider for this NATIVE Oxygen sequence; only 'instantly' is supported here. To push rows into a campaign you already run in Smartlead, lemlist, HeyReach or Instantly, use `oxygen sequences push-external` instead.")
         .option("--email-connection <id>", "Instantly connection id for the email track. Defaults to the org's active Instantly connection.")
         .option("--email-definition-file <path>", "Path to a JSON file with the email content spec (subjects/bodies/delays/subsequences) compiled to an Instantly campaign on start.")
         .option("--max-credits <n>", "Credit cap for the LinkedIn track (also set when starting).")
@@ -13715,6 +14434,13 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             const maxCredits = readPositiveNumber(options.maxCredits);
             const maxLiveSends = readPositiveInt(options.maxLiveSends);
             const settings = readSequenceSettings(options);
+            // `--from-table` is the phrase customers already use for enroll,
+            // so it names the same thing here rather than being a second
+            // concept; `--table` stays for every existing script.
+            const sourceTable = readOption(options.fromTable) ?? readOption(options.table);
+            if (options.enroll && !sourceTable) {
+                throw new Error("--enroll needs a source table: pass --from-table <table> (or --table <table>).");
+            }
             return requestOxygen("/api/cli/sequences", {
                 method: "POST",
                 body: {
@@ -13724,7 +14450,8 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                     ...(channels.length > 0 ? { channels } : {}),
                     ...(senders.length > 0 ? { senders } : {}),
                     ...(tags.length > 0 ? { tags } : {}),
-                    ...(readOption(options.table) ? { source_table_id: readOption(options.table) } : {}),
+                    ...(sourceTable ? { source_table_id: sourceTable } : {}),
+                    ...(options.enroll ? { enroll_from_table: true } : {}),
                     ...(readOption(options.urlColumn) ? { linkedin_url_column_key: readOption(options.urlColumn) } : {}),
                     ...(email ? { email } : {}),
                     ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
@@ -13866,14 +14593,15 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("get")
-        .description("Get a sequence's definition, senders, status, and credit usage.")
+        .description("Get a sequence's definition, senders, status, and credit usage. --readiness adds the launch check — whether it CAN go live, why not, and which mailboxes it would send from — without touching it.")
         .argument("<sequence>", "Sequence id or slug.")
+        .option("--readiness", "Add launch_readiness: blockers (e.g. a missing send cap), warnings, and the resolved sending mailboxes. Read-only — sends nothing, changes nothing, spends nothing. Skips the LinkedIn rendered-copy scan, which stays in `sequences start` without --approved.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleAsyncAction("sequences get", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}`));
+        await handleAsyncAction("sequences get", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}${options.readiness ? "?include=readiness" : ""}`));
     }))
         .addCommand(new Command("enroll")
-        .description("Enroll leads into a sequence. Enrolling spends no credits and sends nothing — dispatch only happens at `sequences start`. --from-table enrolls every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; the response's from_table.has_more says whether to run again) — for a LinkedIn sequence the profile is read from the bound table's URL column, where a full /in/ URL and a bare public handle carrying a hyphen or digit (ada-lovelace) both work, so no pre-resolved provider ids are needed; each handle Oxygen canonicalized is echoed in linkedin_handles_canonicalized (value + url) to check before start, and every row that still cannot be resolved is named in unresolved_linkedin_lead_details (row, value, reason) rather than only counted in unresolved_linkedin_leads. --leads-file enrolls an explicit JSON list { leads: [...] }: for an email/WhatsApp sequence a lead identified only by an email (row_values.email) or phone (row_values.phone) is auto-filed as a row in the sequence's leads table (auto-creating and binding one if there is none), deduped by email/phone, so no table has to exist first (the table is returned as leads_table with a web_url); a LinkedIn lead needs a lead_provider_id, a lead_profile_url (a /in/ URL or a bare public handle with a hyphen or digit), or a table_row_id whose row carries one of those. A CRM-only lead needs a stable table_row_id or lead_provider_id in addition to mapped row_values; a HubSpot contact id used in crm_task associations identifies the destination record, not the Oxygen enrollment. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row (and per email/phone for auto-filed leads). The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason). Leads already owned by a sender account (from an earlier real send) are routed back to that same account; a lead owned by a sender NOT on this sequence is skipped (bound_to_other_sender) unless --ignore-sender-bindings.")
+        .description("Enroll leads into a sequence. Enrolling spends no credits and sends nothing — dispatch only happens at `sequences start`. --from-table enrolls every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; the response's from_table.has_more says whether to run again) — for a LinkedIn sequence the profile is read from the bound table's URL column, where a full /in/ URL and a bare public handle carrying a hyphen or digit (ada-lovelace) both work, so no pre-resolved provider ids are needed; each handle Oxygen canonicalized is echoed in linkedin_handles_canonicalized (value + url) to check before start, and every row that still cannot be resolved is named in unresolved_linkedin_lead_details (row, value, reason) rather than only counted in unresolved_linkedin_leads. --leads-file enrolls an explicit JSON list { leads: [...] }: for an email/WhatsApp sequence a lead identified only by an email (row_values.email) or phone (row_values.phone) is auto-filed as a row in the sequence's leads table (auto-creating and binding one if there is none), deduped by email/phone, so no table has to exist first (the table is returned as leads_table with a web_url); a LinkedIn lead needs a lead_provider_id, a lead_profile_url (a /in/ URL or a bare public handle with a hyphen or digit), or a table_row_id whose row carries one of those. A CRM-only lead needs a stable table_row_id or lead_provider_id in addition to mapped row_values; a HubSpot contact id used in crm_task associations identifies the destination record, not the Oxygen enrollment. When the sequence is bound to a source table, a lead's table_row_id auto-snapshots that row's columns (incl. AI/tool outputs) into row_values for {{column}} copy — explicit row_values win. Idempotent per table row (and per email/phone for auto-filed leads). The org do-not-contact list is always enforced; --exclude-contacted and --suppress-list add further opt-in skips (reported under skipped_by_reason). Leads already owned by a sender account (from an earlier real send) are routed back to that same account; a lead owned by a sender NOT on this sequence is skipped (bound_to_other_sender) unless --ignore-sender-bindings. This enrolls into an OXYGEN Sequence; to put the same rows into a campaign you already run in Smartlead, Instantly, lemlist or HeyReach, use `sequences push-external`.")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--leads-file <path>", "Path to a JSON file: { \"leads\": [{ row_values: { email }, lead_name }] } for cold email; { lead_provider_id, lead_name, table_row_id, row_values } for LinkedIn/existing rows; CRM-only leads require table_row_id or a stable lead_provider_id alongside mapped row_values. A CRM association object id is not the enrollment identity. Exactly one of --leads-file or --from-table.")
         .option("--from-table", "Enroll every not-yet-enrolled row of the sequence's bound source table (up to 500 per run; re-run to continue). Exactly one of --leads-file or --from-table.")
@@ -13914,6 +14642,50 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 },
             });
         });
+    }))
+        .addCommand(new Command("push-external")
+        .description("Push table rows into a campaign you ALREADY run in an external sequencer (Smartlead, Instantly, lemlist, HeyReach), through your own connected API key. This is the External-layer sibling of `sequences enroll`: use it when the campaign lives in that tool and the rows live in Oxygen; for an Oxygen-native Sequence use `sequences create` + `sequences enroll` instead. Oxygen charges 0 credits (BYOK — your provider bills you), but it IS an external write: --mode dry_run (the default) previews the resolved campaign, the exact field mapping, three sample leads and the row counts, and --mode live --approved queues a durable per-row run. Every row gets its own cell holding that row's provider response as provenance, and a row already pushed to this campaign is skipped unless --force. The preview's live_executable reports whether Oxygen can queue the live push for that provider; when it cannot, the preview still gives you the resolved campaign, the mapping and the counts, and names the alternative.")
+        .requiredOption("--provider <provider>", "External sequencer: smartlead, instantly, lemlist, or heyreach.")
+        .requiredOption("--campaign <name-or-id>", "The campaign that already exists in that tool. A name is resolved against your connected account (exact id, then exact name, then a unique partial match).")
+        .requiredOption("--from-table <table>", "Table id or slug whose rows are pushed.")
+        .option("--rows <row_ids>", "Comma-separated row ids to push. Defaults to the whole table.")
+        .option("--filter-json <json>", "Filter object or array selecting the rows, e.g. '{\"column\":\"email\",\"op\":\"is_not_null\"}'.")
+        .option("--mode <mode>", "dry_run (default) or live.")
+        .option("--approved", "Required for --mode live: confirms the external write after inspecting the dry run.")
+        .option("--field-mapping-json <json>", "Override the detected column mapping, e.g. '{\"email\":\"work_email\",\"first_name\":\"fname\"}'. Keys: email, first_name, last_name, company, website, linkedin_url, phone, job_title.")
+        .option("--sender-account <id>", "HeyReach only: the LinkedIn sender account id the leads are added against (list them with `oxygen tools run heyreach.linkedin_accounts_get_all --input-json '{}' --credential-mode user_api_key`).")
+        .option("--connection-id <id>", "Specific integration connection id. Defaults to the workspace's active connection for that provider.")
+        .option("--force", "Push rows again even when they already carry a successful push to this campaign.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleSequenceWriteAction("sequences push-external", options, () => {
+            const rows = readCsvOption(options.rows);
+            const filterJson = readOption(options.filterJson);
+            if (rows.length > 0 && filterJson) {
+                throw new Error("Pass either --rows or --filter-json, not both.");
+            }
+            const selection = rows.length > 0
+                ? { mode: "row_ids", row_ids: rows }
+                : filterJson
+                    ? { mode: "all_matching", filters: JSON.parse(filterJson) }
+                    : null;
+            const fieldMappingJson = readOption(options.fieldMappingJson);
+            return requestOxygen("/api/cli/sequences/push-external", {
+                method: "POST",
+                body: {
+                    provider: readOption(options.provider),
+                    campaign: readOption(options.campaign),
+                    table: readOption(options.fromTable),
+                    mode: readOption(options.mode) ?? "dry_run",
+                    ...(selection ? { selection } : {}),
+                    ...(options.approved ? { approved: true } : {}),
+                    ...(options.force ? { force: true } : {}),
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(readOption(options.senderAccount) ? { sender_account_id: readOption(options.senderAccount) } : {}),
+                    ...(fieldMappingJson ? { field_mapping: parseJsonObject(fieldMappingJson) } : {}),
+                },
+            });
+        }, formatSequencePushExternal);
     }))
         .addCommand(new Command("start")
         .description("Preview or start a sequence. Without --approved this is the launch check: it returns launch_readiness (blockers such as a missing send cap or the WhatsApp cold-initiate opt-in, plus warnings), scans pending LinkedIn copy, and returns exact rendered recipient samples, character counts/limits, copy blockers, per-kind scope, sender/mailbox capacity, CRM readiness, and safety caps. Live start requires --approved; --max-credits is optional. Email/WhatsApp/CRM-task journeys additionally require --max-live-sends because their external actions cost 0 Oxygen credits. Use --dry-run to simulate without any send, provider campaign, CRM task, or credits. The first live start also switches on the standing reply → CRM automation for the workspace.")
@@ -14135,7 +14907,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .argument("<sequence>", "Sequence id or slug.")
         .option("--json", "Print a JSON envelope.")
         .action(async (sequence, options) => {
-        await handleSequenceReadAction("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`), formatSequenceStatsHealth);
+        await handleReadActionWithLens("sequences stats", options, () => requestOxygen(`/api/cli/sequences/${encodeURIComponent(sequence)}/stats`), formatSequenceStatsHealth);
     }))
         .addCommand(new Command("esp")
         .description("ESP breakdown of this sequence's email sending scope: which provider each enrolled lead's mail routes through (google/microsoft, plus named gateways like Proofpoint/Mimecast and non-matchable hosts), folded against your sending mailbox pool. Shows how many leads the CURRENT --esp-matching mode would defer before you turn it on. Resolves domains from MX + SPF (0 credits, DNS only) and caches the result, warming the send path. Preview before flipping strict/prefer.")
@@ -14422,7 +15194,74 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))));
     program.addCommand(new Command("suppressions")
-        .description("Unified do-not-contact controls for people and typed identities. `import-person` bundles one contact's email, LinkedIn, phone, and explicit company domain; `import` preserves the legacy mixed-file contract; `import-identities` is the integration-level typed endpoint; `hubspot lists|sync` arms additive synchronization. Company DNC applies across Sequence channels and is never inferred from a person's email. Consumes 0 credits.")
+        .description("Unified do-not-contact controls for people and typed identities. `policy` decides WHO GETS ADDED automatically -- which replies, bounces, unsubscribes and call outcomes put someone on the list, and whether each one blocks them forever or only stops the current campaign. `crm-backfill` files the people already on the list into your CRM. `import-person` bundles one contact's email, LinkedIn, phone, and explicit company domain; `import` preserves the legacy mixed-file contract; `import-identities` is the integration-level typed endpoint; `hubspot lists|sync` arms additive synchronization. Company DNC applies across Sequence channels and is never inferred from a person's email. Consumes 0 credits.")
+        .addCommand(new Command("policy")
+        .description("Do-not-contact RULES: who gets added to the list automatically. Seven events can add someone -- an email hard bounce, a one-click unsubscribe, opt-out wording in a reply, ANY inbound LinkedIn reply, ANY inbound WhatsApp reply, and the do-not-call / wrong-number call outcomes -- plus an optional rule per inbox reply classification. Each rule is off, stop_only (end this campaign but do not block future ones) or suppress (the default for all seven, and what every version before this did). Blocking itself is never configurable: once someone is on the list they are always skipped. Consumes 0 credits.")
+        .addCommand(new Command("show")
+        .description("Show every do-not-contact rule with its current setting, whether that is your change or the shipped default, and the values it accepts.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions policy", options, () => requestOxygen("/api/cli/suppressions/policy"));
+    }))
+        .addCommand(new Command("set")
+        .description("Change one rule. Example: `oxygen suppressions policy set --rule linkedin_reply --effect stop_only` stops a LinkedIn replier's current campaign without blocking them from every future one.")
+        .requiredOption("--rule <key>", "Rule key from `policy show` (e.g. linkedin_reply, whatsapp_reply, email_hard_bounce, reply_status:not_interested).")
+        .requiredOption("--effect <effect>", "off (do nothing), stop_only (end this enrollment only) or suppress (also add to the do-not-contact list).")
+        .option("--reason <reason>", "Reason stamped on the list entry when the rule suppresses. Defaults to the rule's own.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions policy set", options, () => {
+            const rule = readOption(options.rule);
+            if (!rule)
+                throw new Error("--rule is required.");
+            const effect = readOption(options.effect);
+            if (!effect)
+                throw new Error("--effect is required.");
+            const reason = readOption(options.reason);
+            return requestOxygen("/api/cli/suppressions/policy", {
+                method: "POST",
+                body: { rule, effect, ...(reason ? { reason } : {}) },
+            });
+        });
+    }))
+        .addCommand(new Command("reset")
+        .description("Return one rule (--rule) or every rule (--all) to the shipped default.")
+        .option("--rule <key>", "Rule key to reset.")
+        .option("--all", "Reset every rule instead of one.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions policy set", options, () => {
+            const rule = readOption(options.rule);
+            if (options.all && rule)
+                throw new Error("Pass either --rule or --all, not both.");
+            if (!options.all && !rule)
+                throw new Error("--rule is required (or pass --all).");
+            return requestOxygen("/api/cli/suppressions/policy", {
+                method: "POST",
+                body: options.all ? { reset_all: true } : { rule, reset: true },
+            });
+        });
+    })))
+        .addCommand(new Command("crm-backfill")
+        .description("Create a CRM person record for everyone already on the do-not-contact list, so you can see who they are. New suppressions do this automatically; this covers the ones added before. Previews by default and writes nothing until you pass --live. Consumes 0 credits: it never runs enrichment on the records it creates.")
+        .option("--live", "Actually create the records. Without this the command only reports what it would create.")
+        .option("--limit <n>", "People to process in this call (1-500; default 200).")
+        .option("--offset <n>", "Resume cursor; pass the next_offset from the previous call.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("suppressions crm-backfill", options, () => {
+            const limit = readOption(options.limit);
+            const offset = readOption(options.offset);
+            return requestOxygen("/api/cli/suppressions/crm-backfill", {
+                method: "POST",
+                body: {
+                    ...(options.live ? { live: true } : {}),
+                    ...(limit ? { limit: Number(limit) } : {}),
+                    ...(offset ? { offset: Number(offset) } : {}),
+                },
+            });
+        });
+    }))
         .addCommand(new Command("list")
         .description("List the org's do-not-contact suppressions, newest first. Filter by --reason or by --search (case-insensitive substring of the lead provider id).")
         .option("--reason <reason>", "Filter by reason: manual, replied, unsubscribed, bounced, do_not_contact, friends.")
@@ -15195,7 +16034,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         await handleAsyncAction("mailboxes get", options, () => requestOxygen(`/api/cli/mailboxes/${encodeURIComponent(mailbox)}`));
     }))
         .addCommand(new Command("delete")
-        .description("Preview or approve removal of exact mailboxes from Oxygen at 0 credits. Deletion immediately removes them from sending but never deletes the underlying Google Workspace or Microsoft 365 accounts. It preserves conversation/message/delivery history and stops any separately listed 1,000-credit connected-mailbox commitment for future renewals; that line is currently built but not charged, and it is not the 1,000-credit OXYGEN Warm-up subscription. The current period is not refunded. Listed active/paused sequences keep their status but lose these senders and are not automatically paused. Managed mailboxes and live warmup/monitoring add-ons fail closed with their exact address-scoped teardown steps.")
+        .description("Preview or approve removal of exact mailboxes from Oxygen at 0 credits. Deletion immediately removes them from sending but never deletes the underlying Google Workspace or Microsoft 365 accounts. It preserves conversation/message/delivery history and stops any separately listed 100-credit connected-mailbox commitment for future renewals; that line is currently built but not charged, and it is not the 100-credit OXYGEN Warm-up subscription. The current period is not refunded. Listed active/paused sequences keep their status but lose these senders and are not automatically paused. Managed mailboxes and live warmup/monitoring add-ons fail closed with their exact address-scoped teardown steps.")
         .requiredOption("--mailboxes <list>", "Comma-separated mailbox ids or addresses (maximum 500).")
         .option("--approved", "Execute the fresh preview. Requires --plan-hash and --confirmation.")
         .option("--plan-hash <hash>", "Fresh preview plan_hash.")
@@ -15534,7 +16373,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .addCommand(new Command("emailguard")
         .description("Assess every mailbox origin for EmailGuard and connect credential-capable Google Workspace mailboxes from managed, Zapmail, or compatible encrypted external imports. Manual/native Google rows report credential_required; Microsoft 365/Azure reports vendor_blocked. Preview never materializes a password; approved execution fetches it just in time and never prints it.")
         .addCommand(new Command("connect")
-        .description("Preview or connect selected mailboxes to EmailGuard. Managed mode is 1,000 credits/inbox-month ($1); BYOK is 0 Oxygen credits. Google Workspace requires a real app password, fetched only after approval. Microsoft 365/Azure is explicitly vendor-blocked because EmailGuard exposes neither Microsoft OAuth nor tenant consent; Oxygen never downgrades it to password auth. Starts with a 0-credit, no-provider-write preview. Account connection sends no placement probe.")
+        .description("Preview or connect selected mailboxes to EmailGuard. Managed mode is 100 credits/inbox-month ($1); BYOK is 0 Oxygen credits. Google Workspace requires a real app password, fetched only after approval. Microsoft 365/Azure is explicitly vendor-blocked because EmailGuard exposes neither Microsoft OAuth nor tenant consent; Oxygen never downgrades it to password auth. Starts with a 0-credit, no-provider-write preview. Account connection sends no placement probe.")
         .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses. Omit for the whole pool.")
         .option("--approved", "Perform the external EmailGuard account write.")
         .option("--plan <hash>", "Exact hash from the fresh preview (required with --approved).")
@@ -15651,10 +16490,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("warmup")
-        .description("OXYGEN Warm-up for the sending pool — the weeks of low-volume conversational mail that make a new inbox look trusted before you cold-send from it. It is managed and credit-billed at 1,000 credits per warming inbox per month ($1). Fresh managed InboxKit Google/Microsoft/Azure orders with the default-on warm-up add-on activate automatically after provisioning under the approved order quote; do not run a second `warmup enable`. Google reuses the InboxKit-held credential only during activation and never stores or returns it; Microsoft/Azure uses exact native export. Standalone preview → approval is for BYOK/imported mailboxes, a managed opt-out, or later separate enrollment. InboxKit auto-export stays off for Microsoft/Azure because Oxygen submits only the exact authorized UIDs, and any non-cancelled InboxKit warm-up blocks either handoff so one mailbox cannot warm twice. OXYGEN Warm-up never owns campaign dispatch: native OXYGEN Sequences still own campaigns and sends. Eligible non-InboxKit Microsoft mailboxes use the separate `mailboxes warmup microsoft` OAuth fallback. Inboxes already warming on the retired TrulyInbox rail keep reporting and are wound down there with `warmup disable`; they are never silently moved to the current managed rail.")
+        .description("OXYGEN Warm-up for the sending pool — the weeks of low-volume conversational mail that make a new inbox look trusted before you cold-send from it. It is managed and credit-billed at 100 credits per warming inbox per month ($1). Fresh managed InboxKit Google/Microsoft/Azure orders with the default-on warm-up add-on activate automatically after provisioning under the approved order quote; do not run a second `warmup enable`. Google reuses the InboxKit-held credential only during activation and never stores or returns it; Microsoft/Azure uses exact native export. Standalone preview → approval is for BYOK/imported mailboxes, a managed opt-out, or later separate enrollment. InboxKit auto-export stays off for Microsoft/Azure because Oxygen submits only the exact authorized UIDs, and any non-cancelled InboxKit warm-up blocks either handoff so one mailbox cannot warm twice. OXYGEN Warm-up never owns campaign dispatch: native OXYGEN Sequences still own campaigns and sends. Eligible non-InboxKit Microsoft mailboxes use the separate `mailboxes warmup microsoft` OAuth fallback. Inboxes already warming on the retired TrulyInbox rail keep reporting and are wound down there with `warmup disable`; they are never silently moved to the current managed rail.")
         .addHelpText("after", "\nDocs: https://oxygen-agent.com/docs/providers/mailboxes\n")
         .addCommand(new Command("enable")
-        .description("STANDALONE ENROLLMENT: enroll BYOK/imported mailboxes, a managed order that opted out, or mailboxes being added to warmup later. Fresh managed InboxKit Google/Microsoft/Azure orders whose approved quote included warmup activate automatically after provisioning and do not need this command. Targets the whole pool unless --mailboxes is given; one synchronous preview/approval is capped at 220 mailboxes, so split larger pools into explicit batches. Without --approved this is a 0-credit, no-provider-write priced preview: nothing is handed off, enrolled, or billed. The current public price is 1,000 credits per warming mailbox-month; the preview returns the exact first-cycle ceiling. Preview one inbox with `oxygen mailboxes warmup enable --mailboxes sender@example.com --json`. Execute by echoing its --plan and --max-credits with --approved. Eligible managed Google targets use the InboxKit-held credential just in time without storing or returning it; Microsoft/Azure targets use native InboxKit Sequencer export with exact UIDs and auto-export off. Any non-cancelled InboxKit warmup must be cancelled before either handoff (pausing is not enough). Only eligible non-InboxKit Microsoft mailboxes need `mailboxes warmup microsoft`. OXYGEN Warm-up retains no campaign authority — OXYGEN Sequences own enrollment and dispatch. New enrollments only ever land on the managed OXYGEN rail; the retired TrulyInbox rail is refused here and only accepts teardown.")
+        .description("STANDALONE ENROLLMENT: enroll BYOK/imported mailboxes, a managed order that opted out, or mailboxes being added to warmup later. Fresh managed InboxKit Google/Microsoft/Azure orders whose approved quote included warmup activate automatically after provisioning and do not need this command. Targets the whole pool unless --mailboxes is given; one synchronous preview/approval is capped at 220 mailboxes, so split larger pools into explicit batches. Without --approved this is a 0-credit, no-provider-write priced preview: nothing is handed off, enrolled, or billed. The current public price is 100 credits per warming mailbox-month; the preview returns the exact first-cycle ceiling. Preview one inbox with `oxygen mailboxes warmup enable --mailboxes sender@example.com --json`. Execute by echoing its --plan and --max-credits with --approved. Eligible managed Google targets use the InboxKit-held credential just in time without storing or returning it; Microsoft/Azure targets use native InboxKit Sequencer export with exact UIDs and auto-export off. Any non-cancelled InboxKit warmup must be cancelled before either handoff (pausing is not enough). Only eligible non-InboxKit Microsoft mailboxes need `mailboxes warmup microsoft`. OXYGEN Warm-up retains no campaign authority — OXYGEN Sequences own enrollment and dispatch. New enrollments only ever land on the managed OXYGEN rail; the retired TrulyInbox rail is refused here and only accepts teardown.")
         .addHelpText("after", "\nDocs: https://oxygen-agent.com/docs/providers/mailboxes\n")
         .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses to warm. Omit to warm the whole pool.")
         .option("--approved", "Execute the PRICED enrollment. Without it the response is a priced preview and nothing is enrolled or billed.")
@@ -15884,7 +16723,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         });
     }))
         .addCommand(new Command("disable")
-        .description("Disable warmup and unenroll each mailbox from the rail that actually enrolled it. On a managed rail — OXYGEN Warm-up today, TrulyInbox for older enrollments — this also cancels that mailbox's warmup subscription, so billing stops with the provider removal. This is how you wind an inbox off the retired TrulyInbox rail. NOT the way to fix a rotated app password — use `mailboxes warmup reconnect` for that, which costs 0 credits instead of a new 1,000-credit month. Targets the whole pool unless --mailboxes is given.")
+        .description("Disable warmup and unenroll each mailbox from the rail that actually enrolled it. On a managed rail — OXYGEN Warm-up today, TrulyInbox for older enrollments — this also cancels that mailbox's warmup subscription, so billing stops with the provider removal. This is how you wind an inbox off the retired TrulyInbox rail. NOT the way to fix a rotated app password — use `mailboxes warmup reconnect` for that, which costs 0 credits instead of a new 100-credit month. Targets the whole pool unless --mailboxes is given.")
         .option("--mailboxes <list>", "Comma-separated mailbox ids or addresses. Omit for the whole pool.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
@@ -17306,7 +18145,7 @@ Full trigger schema: oxygen workflows schema --subject trigger --json
         .option("--api-url <url>", "Oxygen app URL. Defaults to OXYGEN_API_URL or https://oxygen-agent.com.")
         .option("--agents <agents...>", "Space or comma separated agents. Defaults to codex, claude-code, and cursor.")
         .option("--skill <skill>", "Skill name or '*'. Defaults to '*'.")
-        .option("--project", "Install into the current project instead of global agent scope.")
+        .option("--project", "Install into the current project instead of global agent scope. A flag with no value: run it from the project directory; a path argument is rejected.")
         .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) => {
@@ -18625,7 +19464,9 @@ function printColumnCatalog(result) {
     const entries = data && Array.isArray(data.entries) ? data.entries.filter(isRecord) : [];
     const bundles = data && Array.isArray(data.bundles) ? data.bundles.filter(isRecord) : [];
     if (entries.length === 0 && bundles.length === 0) {
-        process.stderr.write("No column templates match.\n");
+        process.stderr.write("No column templates match. No preset bundle matches either.\n"
+            + "A template is one column (`columns add <table> --prompt-key <key>`); a bundle is a preset that creates several at once (`columns add <table> --preset <id>`).\n"
+            + "Shorten --search, drop it, or pick a section: `columns catalog --category people`.\n");
         return;
     }
     const byFamily = new Map();
@@ -18677,6 +19518,9 @@ function printColumnCatalog(result) {
     lines.push("");
     lines.push("Prices: a fixed figure is what every row costs; `~X credits/row (up to Y)` is X when the first grounding lane answers and Y reserved per row — `columns run --dry-run` quotes Y for your rows.");
     lines.push("Add one: oxygen columns add <table> --prompt-key <key> --input <input>=<column_key>, then `columns run <table> <key> --dry-run` for the exact cost.");
+    // The blind acceptance judge watched an agent filter this list with python3
+    // because nothing on screen said the command can narrow itself.
+    lines.push("Narrow this list: --family pricing|job_posting|events|filings|site_facts|market|portfolio|text_extraction, --category extract, --search <word>, --kind research|ai|formula. Credits are the reserved ceiling per row (primary lane + fallback); a typical row spends the primary lane only.");
     process.stderr.write(`${lines.join("\n")}\n`);
 }
 function applyAiColumnConfig(definition, options) {
@@ -19415,6 +20259,7 @@ function readFeedBindBody(table, options) {
         feed_kind: options.kind,
         route: {
             tool_id: options.toolId,
+            // assertPullFeedBindArguments guarantees --request-json before this reader runs.
             request: parseJsonObject(readFileIfPresent(options.requestJson)),
             ...(toolIds.length > 0 ? { tool_ids: toolIds } : {}),
             ...(readOption(options.rowsPath) ? { rows_path: readOption(options.rowsPath) } : {}),
@@ -19438,6 +20283,225 @@ function readFeedBindBody(table, options) {
         ...(options.approved ? { approved: true } : {}),
     };
 }
+// `feeds bind` is one verb over two transports, told apart by --schema-json. Each
+// list names the flags that only mean something on one side, in help order, so a
+// flag from the other transport is refused by name instead of silently dropped.
+const FEED_BIND_PULL_ONLY_FLAGS = [
+    ["kind", "--kind"],
+    ["toolId", "--tool-id"],
+    ["toolIds", "--tool-ids"],
+    ["requestJson", "--request-json"],
+    ["rowsPath", "--rows-path"],
+    ["rowMappingJson", "--row-mapping-json"],
+    ["cursorPath", "--cursor-path"],
+    ["cursorRequestKey", "--cursor-request-key"],
+    ["maxPages", "--max-pages"],
+    ["every", "--every"],
+    ["maxCredits", "--max-credits"],
+    ["maxRows", "--max-rows"],
+    ["filtersJson", "--filters-json"],
+    ["intentId", "--intent-id"],
+    ["inputShape", "--input-shape"],
+    ["routeId", "--route-id"],
+    ["sourcePrompt", "--source-prompt"],
+    ["approved", "--approved"],
+];
+const FEED_BIND_PUSH_ONLY_FLAGS = [
+    ["create", "--create"],
+    ["itemsPath", "--items-path"],
+    ["eventIdPath", "--event-id-path"],
+    ["eventTypePath", "--event-type-path"],
+    ["occurredAtPath", "--occurred-at-path"],
+    ["authMode", "--auth-mode"],
+];
+// The third mode: a WEB INTENT feed, named by source instead of configured.
+// OXYGEN's own receiver normalizes every reveal, so there is nothing to declare —
+// which is also why this list is the accepted values rather than a free string.
+const FEED_BIND_WEB_INTENT_SOURCES = ["rb2b"];
+// Everything a web-intent feed cannot carry, in help order. --create, --name and
+// --upsert-key are its only companions, so a flag belonging to either other mode
+// is refused here by name, one round trip before the server would refuse it.
+const FEED_BIND_WEB_INTENT_REFUSED_FLAGS = [
+    ["schemaJson", "--schema-json"],
+    ...FEED_BIND_PULL_ONLY_FLAGS,
+    ...FEED_BIND_PUSH_ONLY_FLAGS.filter(([key]) => key !== "create"),
+];
+// Pull mode keeps the contract commander enforced when --kind/--tool-id/
+// --request-json were requiredOptions and <table> was required: same messages, same
+// order (mandatory options before the argument), same stderr + exit 1 path. They
+// stopped being commander-required only because a push feed must not carry them.
+function assertPullFeedBindArguments(table, options, command) {
+    for (const [key, flag] of FEED_BIND_PUSH_ONLY_FLAGS) {
+        if (options[key] !== undefined) {
+            command.error(`error: ${flag} belongs to a push feed; add --schema-json <json-or-file> to bind one, or drop ${flag} to bind a pull feed.`);
+        }
+    }
+    const required = [
+        ["kind", "--kind <kind>"],
+        ["toolId", "--tool-id <tool>"],
+        ["requestJson", "--request-json <json-or-file>"],
+    ];
+    for (const [key, flags] of required) {
+        if (options[key] === undefined) {
+            command.error(`error: required option '${flags}' not specified`, { code: "commander.missingMandatoryOptionValue" });
+        }
+    }
+    if (table === undefined) {
+        command.error("error: missing required argument 'table'", { code: "commander.missingArgument" });
+    }
+}
+// The push bind body mirrors the route's declared-schema reader: transport push, the
+// schema as an OBJECT (the server validates it against the table's real columns),
+// and exactly one of an existing table or create_table. Pull fields are refused here
+// by flag name, before any request, because the server would 400 on them anyway.
+function readFeedPushBindBody(table, options) {
+    for (const [key, flag] of FEED_BIND_PULL_ONLY_FLAGS) {
+        if (options[key] !== undefined) {
+            throw new OxygenError("invalid_table_feed", `${flag} belongs to a pull feed; a push feed is filled by whatever posts to its endpoint. Drop ${flag}, or drop --schema-json to bind a pull feed.`, { details: { flag }, exitCode: 1 });
+        }
+    }
+    const schemaSource = readOption(options.schemaJson);
+    if (!schemaSource) {
+        throw new OxygenError("invalid_json", "--schema-json needs a JSON Schema object, inline or a path to a JSON file.", { exitCode: 1 });
+    }
+    const rowSchema = parseJsonObject(readFileIfPresent(schemaSource));
+    const tableRef = readOption(table);
+    const create = readOption(options.create);
+    if (tableRef && create) {
+        throw new OxygenError("invalid_request", "Pass a table or --create <name>, not both.", { exitCode: 1 });
+    }
+    if (!tableRef && !create) {
+        throw new OxygenError("invalid_request", "Pass the table id or slug that receives the rows, or --create <name> to create the table from the schema.", { exitCode: 1 });
+    }
+    const authMode = readOption(options.authMode);
+    if (authMode && authMode !== "secret" && authMode !== "none") {
+        throw new OxygenError("invalid_request", "--auth-mode must be secret or none.", { details: { auth_mode: authMode }, exitCode: 1 });
+    }
+    return {
+        transport: "push",
+        row_schema: rowSchema,
+        ...(tableRef ? { table: tableRef } : { create_table: { name: create } }),
+        ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+        ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+        ...(readOption(options.itemsPath) ? { items_path: readOption(options.itemsPath) } : {}),
+        ...(readOption(options.eventIdPath) ? { event_id_path: readOption(options.eventIdPath) } : {}),
+        ...(readOption(options.eventTypePath) ? { event_type_path: readOption(options.eventTypePath) } : {}),
+        ...(readOption(options.occurredAtPath) ? { occurred_at_path: readOption(options.occurredAtPath) } : {}),
+        ...(authMode ? { auth_mode: authMode } : {}),
+    };
+}
+// The web-intent bind body: transport push plus the source as the feed kind, and
+// exactly one of an existing table or create_table. Nothing else is accepted —
+// the reveal shape, the address, and the (zero) cost are all fixed by OXYGEN's own
+// receiver — so every other flag is refused here by name, before any request.
+function readFeedWebIntentBindBody(table, options) {
+    const source = readOption(options.source);
+    if (!source || !FEED_BIND_WEB_INTENT_SOURCES.includes(source)) {
+        throw new OxygenError("invalid_request", `--source must be one of: ${FEED_BIND_WEB_INTENT_SOURCES.join(", ")}.`, { details: { source: source ?? null, accepted: [...FEED_BIND_WEB_INTENT_SOURCES] }, exitCode: 1 });
+    }
+    for (const [key, flag] of FEED_BIND_WEB_INTENT_REFUSED_FLAGS) {
+        if (options[key] !== undefined) {
+            throw new OxygenError("invalid_table_feed", `${flag} does not apply to a --source ${source} feed: its rows come from OXYGEN's own website-visit receiver with a fixed shape. Drop ${flag}, or drop --source to bind a pull or --schema-json feed.`, { details: { flag, source }, exitCode: 1 });
+        }
+    }
+    const tableRef = readOption(table);
+    const create = readOption(options.create);
+    if (tableRef && create) {
+        throw new OxygenError("invalid_request", "Pass a table or --create <name>, not both.", { exitCode: 1 });
+    }
+    if (!tableRef && !create) {
+        throw new OxygenError("invalid_request", "Pass the table id or slug that receives the reveals, or --create <name> to create the table with the fixed reveal columns.", { exitCode: 1 });
+    }
+    return {
+        transport: "push",
+        feed_kind: source,
+        ...(tableRef ? { table: tableRef } : { create_table: { name: create } }),
+        ...(readOption(options.name) ? { name: readOption(options.name) } : {}),
+        ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+    };
+}
+// Human receipt for a web-intent bind. There is no secret and no webhook URL to
+// print — this feed has no address — so what a reader needs instead is the table
+// the reveals land in, that they cost nothing, and the one precondition that
+// decides whether any row ever appears.
+function writeFeedWebIntentBindReceipt(data) {
+    if (!isRecord(data))
+        return;
+    const feed = isRecord(data.feed) ? data.feed : {};
+    const table = isRecord(feed.table) ? feed.table : {};
+    const lines = [];
+    const feedId = readRecordString(feed, "id");
+    lines.push(`Web intent feed "${readRecordString(feed, "name") ?? "unnamed"}"${feedId ? ` (${feedId})` : ""} bound: RB2B website-visit reveals now land as rows.`);
+    const tableName = readRecordString(table, "display_name");
+    const tableSlug = readRecordString(table, "slug") ?? readRecordString(table, "id");
+    if (tableName || tableSlug) {
+        lines.push(`  Table: ${tableName ?? tableSlug}${tableName && tableSlug ? ` (${tableSlug})` : ""}`);
+    }
+    const upsertKey = readRecordString(feed, "upsert_key");
+    if (upsertKey)
+        lines.push(`  Upserted on: ${upsertKey}`);
+    lines.push("  Cost: 0 credits per reveal. Every reveal also stays a website_visit Signal.");
+    lines.push("  Rows only start once RB2B is connected to this workspace; there is no self-serve connect step yet.");
+    const nextStep = readRecordString(data, "next_step");
+    if (nextStep)
+        lines.push(`  Next: ${nextStep}`);
+    const webUrl = readRecordString(data, "web_url") ?? readRecordString(data, "deepLink");
+    if (webUrl)
+        lines.push(`  ${webUrl}`);
+    process.stderr.write(`${lines.join("\n")}\n`);
+}
+// Human receipt for a push-feed bind, on stderr ahead of the payload (stdout stays
+// the machine JSON, like every other command). The secret is returned exactly once —
+// only its hash is stored — so it is printed with the warning right next to it.
+function writeFeedPushBindReceipt(data) {
+    if (!isRecord(data))
+        return;
+    const feed = isRecord(data.feed) ? data.feed : {};
+    const table = isRecord(feed.table) ? feed.table : {};
+    const lines = [];
+    const feedId = readRecordString(feed, "id");
+    lines.push(`Push feed "${readRecordString(feed, "name") ?? "unnamed"}"${feedId ? ` (${feedId})` : ""} bound: typed or rejected.`);
+    const tableName = readRecordString(table, "display_name");
+    const tableSlug = readRecordString(table, "slug") ?? readRecordString(table, "id");
+    if (tableName || tableSlug) {
+        lines.push(`  Table: ${tableName ?? tableSlug}${tableName && tableSlug ? ` (${tableSlug})` : ""}`);
+    }
+    const webhookUrl = readRecordString(data, "webhookUrl") ?? readRecordString(feed, "endpoint_url");
+    if (webhookUrl)
+        lines.push(`  Webhook URL: ${webhookUrl}`);
+    const secret = readRecordString(data, "secret");
+    if (secret) {
+        lines.push(`  Secret: ${secret}`);
+        lines.push("  This secret is shown once and never again: store it now. Senders pass it in the x-oxygen-table-webhook-secret header.");
+    }
+    else {
+        lines.push("  No secret (auth mode none): anyone holding the webhook URL can post.");
+    }
+    const schema = isRecord(data.row_schema) ? data.row_schema : isRecord(feed.row_schema) ? feed.row_schema : null;
+    const properties = schema && isRecord(schema.properties) ? schema.properties : {};
+    const required = new Set(schema && Array.isArray(schema.required) ? schema.required.filter((entry) => typeof entry === "string") : []);
+    const names = Object.keys(properties);
+    lines.push(`  Row schema (${names.length} propert${names.length === 1 ? "y" : "ies"}; a delivery that does not match is refused with 422):`);
+    for (const name of names) {
+        const property = properties[name];
+        const type = isRecord(property)
+            ? Array.isArray(property.type)
+                ? property.type.filter((entry) => typeof entry === "string").join("|")
+                : typeof property.type === "string" ? property.type : "any"
+            : "any";
+        lines.push(`    ${name}: ${type || "any"}${required.has(name) ? " (required)" : ""}`);
+    }
+    if (schema?.additionalProperties === false)
+        lines.push("    no other properties allowed");
+    lines.push("  Cost: 0 credits per delivery.");
+    const nextStep = readRecordString(data, "next_step");
+    if (nextStep)
+        lines.push(`  Next: ${nextStep}`);
+    const webUrl = readRecordString(data, "web_url") ?? readRecordString(data, "deepLink");
+    if (webUrl)
+        lines.push(`  ${webUrl}`);
+    process.stderr.write(`${lines.join("\n")}\n`);
+}
 function readSignalsSearchPlanBody(options, promptArg) {
     // The prompt may arrive as --prompt or as the positional argument; the flag wins.
     const promptSource = options.prompt ?? promptArg;
@@ -19550,8 +20614,8 @@ function readCompaniesSearchRunBody(options, promptArg) {
     const promptSource = options.prompt ?? promptArg;
     const prompt = promptSource ? readFileIfPresent(promptSource) : null;
     const plan = options.planJson ? readSearchPlanJson(options.planJson) : null;
-    if (!prompt && !plan && options.source !== "company_search") {
-        throw new OxygenError("invalid_request", "Pass --prompt, --plan-json, or --source company_search with --source-filters-json.", { exitCode: 1 });
+    if (!prompt && !plan && options.source !== "company_search" && options.source !== "hiring") {
+        throw new OxygenError("invalid_request", "Pass --prompt, --plan-json, or --source company_search|hiring with --source-filters-json.", { exitCode: 1 });
     }
     const maxPages = readPositiveInt(options.maxPages);
     const maxCredits = readPositiveNumber(options.maxCredits);
@@ -19562,6 +20626,7 @@ function readCompaniesSearchRunBody(options, promptArg) {
         ...(plan ? { plan } : {}),
         ...(options.source ? { source: options.source } : {}),
         ...(options.sourceFiltersJson ? { source_filters: parseJsonObject(readFileIfPresent(options.sourceFiltersJson)) } : {}),
+        ...(readOption(options.tableName) ? { table_name: readOption(options.tableName) } : {}),
         ...(options.routeId ? { route_id: options.routeId } : {}),
         ...(options.toolId ? { tool_id: options.toolId } : {}),
         ...(options.table ? { table: options.table } : {}),
@@ -19712,7 +20777,7 @@ function readSearchPlanJson(value) {
 }
 // Table-driven Employee Finder help, written once and shared by `people search
 // plan` and `people search run` so the price shape reads the same on both.
-const PEOPLE_SEARCH_FROM_TABLE_HELP = "Fan out Blitz Employee Finder over every company LinkedIn URL in a table column: 10 credits per company per page, rows land in a new people table linked back to each company row. Pass the table id or slug, plus --linkedin-url-column.";
+const PEOPLE_SEARCH_FROM_TABLE_HELP = "Search every company LinkedIn URL in a table column for the people you describe — --titles, --exclude-titles, --seniorities, --job-functions, --education, location and --min-connections all apply per company. 10 credits per company per page; rows land in a new people table with a company relation back to each source row. Pass the table id or slug plus --linkedin-url-column, and bound it with --company-limit. For up to 50 companies this is the expensive way: people search preview with company.linkedin_url samples them free and people search run --source people_search charges one page across all of them.";
 const PEOPLE_SEARCH_LINKEDIN_COLUMN_HELP = "Column key in --from-table holding each company's LinkedIn URL.";
 const PEOPLE_SEARCH_COMPANY_OFFSET_HELP = "Skip this many companies in --from-table. Use it to source the rest after a first-company preview.";
 const PEOPLE_SEARCH_COMPANY_LIMIT_HELP = "Fetch people for at most this many companies from --from-table. Start with --company-limit 1.";
@@ -19724,6 +20789,18 @@ const PEOPLE_SEARCH_MIN_CONNECTIONS_HELP = "Only return people with at least thi
 // offset/limit window rides INSIDE `source` when the source is declared here; with
 // a saved plan it rides as `source_overrides`, which the run route applies on top
 // of the plan's own source.
+/** The company lanes that share Company Search's flow; anything else is a typo, not a provider. */
+function readCompanySearchSource(value) {
+    const source = readOption(value) ?? "company_search";
+    if (source !== "company_search" && source !== "hiring") {
+        throw new OxygenError("invalid_request", "--source must be company_search or hiring.", { exitCode: 1 });
+    }
+    return source;
+}
+function readCompanySourceQuery(value) {
+    const source = readCompanySearchSource(value);
+    return source === "company_search" ? "" : `?source=${source}`;
+}
 function readPeopleSearchSource(options) {
     const table = readOption(options.fromTable);
     const column = readOption(options.linkedinUrlColumn);
@@ -19784,13 +20861,36 @@ function readPeopleSearchPlanBody(options) {
 }
 function readPeopleSearchRunBody(options) {
     const plan = options.planJson ? readSearchPlanJson(options.planJson) : null;
+    // --source people_search is the Find people lane: the free preview's filters
+    // ARE the request, so no prompt, plan or companies table is synthesized.
+    if (options.source !== undefined && options.source !== "people_search") {
+        throw new OxygenError("invalid_request", "--source must be people_search; use --from-table for people at your companies.", { exitCode: 1 });
+    }
+    if (options.source === "people_search") {
+        if (!options.sourceFiltersJson) {
+            throw new OxygenError("invalid_request", "--source people_search needs --source-filters-json (the same filters as people search preview).", { exitCode: 1 });
+        }
+        const maxCreditsNative = readPositiveNumber(options.maxCredits);
+        const nativeTarget = readPositiveInt(options.targetCount);
+        return {
+            source: "people_search",
+            source_filters: parseJsonObject(readFileIfPresent(options.sourceFiltersJson)),
+            ...(readOption(options.tableName) ? { table_name: readOption(options.tableName) } : {}),
+            ...(options.table ? { table: options.table } : {}),
+            ...(options.project ? { project: options.project } : {}),
+            ...(options.mode ? { mode: options.mode } : {}),
+            ...(maxCreditsNative !== undefined ? { max_credits: maxCreditsNative } : {}),
+            ...(nativeTarget !== undefined ? { target_count: nativeTarget } : {}),
+            ...(options.approved ? { approved: true } : {}),
+        };
+    }
     const source = readPeopleSearchSource(options);
     // --from-table is itself the request, so it satisfies the prompt requirement the
     // same way --plan-json does. A submitted plan already carries its own source and
     // prompt, so nothing is synthesized on top of one.
     const prompt = readPeopleSearchPrompt(options, plan ? null : source);
     if (!prompt && !plan) {
-        throw new OxygenError("invalid_request", "Pass --prompt, --plan-json, or --from-table with --linkedin-url-column.", { exitCode: 1 });
+        throw new OxygenError("invalid_request", "Pass --prompt, --plan-json, --from-table with --linkedin-url-column, or --source people_search with --source-filters-json.", { exitCode: 1 });
     }
     const maxPages = readPeopleSearchMaxPages(options);
     const maxCredits = readPositiveNumber(options.maxCredits);
@@ -20037,8 +21137,49 @@ function normalizeSessionStepStatus(value) {
         exitCode: 1,
     });
 }
-// skipcq: JS-R1005 — intentional branching over file format, create/upsert, and sync/background import modes
+/**
+ * `--url` hands the fetch to the server: the same durable import the file path
+ * enqueues, with the bytes read by OXYGEN behind SSRF, size and content guards,
+ * so the CLI never downloads anything and a 0-credit preview is one flag away.
+ */
+async function importRowsFromUrl(table, options) {
+    if (options.create && table) {
+        throw new OxygenError("invalid_import_target", "Pass either a table argument or --create, not both.", { exitCode: 1 });
+    }
+    if (!options.preview && !options.create && !table) {
+        throw new OxygenError("invalid_import_target", "Pass a table argument or --create <name>, or add --preview to look first.", { exitCode: 1 });
+    }
+    const result = await requestOxygen("/api/cli/tables/import-from-url", {
+        method: "POST",
+        timeoutMs: 120_000,
+        body: {
+            url: options.url,
+            mode: options.preview ? "preview" : "import",
+            ...(table ? { table } : {}),
+            ...(options.create ? { create_name: options.create } : {}),
+            ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
+            ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+            ...(readOption(options.format) ? { format: readOption(options.format) } : {}),
+            ...(readOption(options.sheet) ? { sheet: readOption(options.sheet) } : {}),
+        },
+    });
+    if (options.preview)
+        return result;
+    emitQueueWaitStderrNote(readRecord(result, "queue_wait"));
+    return withImportWaitNextStep({ ...result, background: true, autoBackground: true });
+}
 async function importRows(table, options) {
+    if (options.url)
+        return importRowsFromUrl(table, { ...options, url: options.url });
+    if (!options.file) {
+        throw new OxygenError("invalid_request", "Pass --file <path> or --url <https-link>.", { exitCode: 1 });
+    }
+    if (options.preview) {
+        throw new OxygenError("invalid_request", "--preview only applies to --url imports.", { exitCode: 1 });
+    }
+    return importRowsFromFile(table, { ...options, file: options.file });
+}
+async function importRowsFromFile(table, options) {
     const format = normalizeRowsFormat(options.format, inferRowsFileFormat(options.file));
     const parsedRows = await readRowsFile(options.file, format, options.sheet);
     if (parsedRows.length === 0) {
@@ -21679,13 +22820,6 @@ function escapeCsvField(value) {
             : String(value);
     return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, "\"\"")}"` : text;
 }
-function chunk(values, size) {
-    const chunks = [];
-    for (let index = 0; index < values.length; index += size) {
-        chunks.push(values.slice(index, index + size));
-    }
-    return chunks;
-}
 function readCount(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -23192,20 +24326,181 @@ function renderTextTable(headers, rows) {
 // Sequence state is derived only by the shared API. These helpers render those
 // facts; they never infer flowing/blocked/live client-side. JSON remains the
 // untouched API data inside the standard CLI envelope.
-const SEQUENCE_OPERATIONAL_STATE_ORDER = ["empty", "drained", "blocked", "degraded", "flowing", "paced"];
-async function handleSequenceReadAction(command, options, action, render) {
+const SEQUENCE_OPERATIONAL_STATE_ORDER = ["empty", "drained", "never_started", "blocked", "degraded", "flowing", "paced"];
+/**
+ * `crm objects`, as an operator reads it.
+ *
+ * Every crm command printed raw JSON whether or not you asked for it, so the
+ * 2026-09-20 blind eval's agent piped this exact command through `python3 -c`
+ * just to see which objects existed. A list of four objects should not need a
+ * program to read. `--json` is untouched and remains the contract.
+ */
+const CRM_NORMALIZATION_WORDS = {
+    email_v1: "email address",
+    domain_v1: "website domain",
+    linkedin_url_v1: "LinkedIn URL",
+    exact_text_v1: "exact text",
+    uuid_v1: "ID",
+};
+function formatCrmObjects(data) {
+    const objects = Array.isArray(data.objects) ? data.objects.filter(isRecord) : [];
+    if (objects.length === 0) {
+        return "No CRM objects yet. Create the standard set with: oxygen crm setup --live\n";
+    }
+    const rows = objects.map((object) => {
+        const attributes = Array.isArray(object.attributes) ? object.attributes.filter(isRecord) : [];
+        const identities = Array.isArray(object.identities) ? object.identities.filter(isRecord) : [];
+        // System attributes are bookkeeping, not fields anyone chose.
+        const fieldCount = attributes.filter((attribute) => attribute.attributeKind !== "system").length;
+        const primary = identities.find((identity) => identity.isPrimary === true) ?? identities[0];
+        return [
+            String(object.pluralName || object.displayName || object.slug || "—"),
+            object.standardKey ? "standard" : "custom",
+            String(fieldCount),
+            describeCrmIdentity(primary, attributes),
+            String(object.slug ?? "—"),
+        ];
+    });
+    return [
+        `${objects.length} object${objects.length === 1 ? "" : "s"}`,
+        "",
+        ...renderTextTable(["OBJECT", "KIND", "FIELDS", "SAME RECORD WHEN", "SLUG"], rows),
+        "",
+        "  One object's fields and links:  oxygen crm describe <slug>",
+        "  In the app:                     /settings/data-model",
+        "",
+    ].join("\n");
+}
+/** "Website domain (website domain)" is noise, so the comparison is named only
+ *  when it says something the field name does not. An object with no identity
+ *  is called out rather than left blank: it duplicates on every re-import. */
+function describeCrmIdentity(identity, attributes) {
+    if (!identity)
+        return "nothing — can duplicate";
+    const attributeSlug = typeof identity.attributeSlug === "string" ? identity.attributeSlug : null;
+    const attribute = attributeSlug
+        ? attributes.find((candidate) => candidate.slug === attributeSlug)
+        : undefined;
+    const fieldName = String(attribute?.displayName ?? identity.displayName ?? attributeSlug ?? "—");
+    const normalization = typeof identity.normalization === "string" ? identity.normalization : "";
+    const words = CRM_NORMALIZATION_WORDS[normalization];
+    return words && words !== fieldName.toLowerCase() ? `${fieldName} (${words})` : fieldName;
+}
+/** A read command that prints a readable block instead of the raw envelope.
+ *  `--json` still emits the untouched API envelope, so the lens is presentation
+ *  only and never becomes a second contract. Used by the sequencer lenses and by
+ *  `crm objects`. */
+async function handleReadActionWithLens(command, options, action, render) {
+    try {
+        const data = await action();
+        if (options.json) {
+            writeJson(success(command, data));
+            return;
+        }
+        process.stdout.write(isRecord(data) ? render(data) : `${JSON.stringify(data, null, 2)}\n`);
+    }
+    catch (error) {
+        emitCliFailure(command, error);
+    }
+}
+/**
+ * A state-changing sequencer command that prints a readable block instead of the
+ * raw envelope. Same shape as `handleReadActionWithLens`, plus the billing
+ * notices every write path owes the operator.
+ */
+async function handleSequenceWriteAction(command, options, action, render) {
     try {
         const data = await action();
+        writeBillingNotices(command, data);
         if (options.json) {
             writeJson(success(command, data));
             return;
         }
         process.stdout.write(isRecord(data) ? render(data) : `${JSON.stringify(data, null, 2)}\n`);
+        writeCreditsReceipt(data);
     }
     catch (error) {
         emitCliFailure(command, error);
     }
 }
+/**
+ * The external-campaign push, in the shape an operator reads before approving:
+ * what campaign it resolved, what is mapped onto which column, how many rows
+ * each gate drops, and — when something is in the way — the one command that
+ * clears it. A dry run that is blocked still prints the row counts, because
+ * "you are not connected" and "your table has no emails" are different problems
+ * and the operator should learn both in one pass.
+ */
+function formatSequencePushExternal(data) {
+    const lines = [];
+    const provider = stringValue(data.provider) ?? "provider";
+    const campaign = recordValue(data.campaign);
+    const resolved = recordValue(campaign.resolved);
+    const table = recordValue(data.table);
+    const rows = recordValue(data.rows);
+    const live = stringValue(data.mode) === "live";
+    const campaignName = stringValue(resolved.name) ?? stringValue(campaign.name);
+    const campaignId = stringValue(resolved.id) ?? stringValue(campaign.id);
+    lines.push(campaignName
+        ? `${live ? "Pushing to" : "Preview: push to"} ${provider} campaign "${campaignName}"${campaignId ? ` (${campaignId})` : ""}`
+        : `${live ? "Pushing to" : "Preview: push to"} ${provider} campaign "${stringValue(campaign.requested) ?? "?"}" — NOT RESOLVED (${stringValue(campaign.reason) ?? "unknown"})`);
+    lines.push(`Table: ${stringValue(table.display_name) ?? stringValue(table.slug) ?? stringValue(table.id) ?? "?"}`);
+    const connection = recordValue(data.connection);
+    if (stringValue(connection.status) === "missing") {
+        lines.push(`Connection: NOT CONNECTED — ${stringValue(connection.connect_command) ?? `oxygen integrations connect ${provider} --api-key <key>`}`);
+    }
+    else if (stringValue(connection.connection_id)) {
+        lines.push(`Connection: ${stringValue(connection.connection_id)}`);
+    }
+    const identityField = stringValue(rows.identity_field) ?? "email";
+    lines.push([
+        `Rows: ${numericValue(rows.scoped) ?? 0} scoped`,
+        `${numericValue(rows.with_identity) ?? 0} with ${identityField}`,
+        `${numericValue(rows.missing_identity) ?? 0} missing ${identityField}`,
+        `${numericValue(rows.duplicate_identity) ?? 0} duplicate`,
+        `${numericValue(rows.already_pushed) ?? 0} already pushed`,
+        `${numericValue(rows.to_push) ?? 0} to push`,
+    ].join(" | "));
+    if (rows.has_more === true) {
+        lines.push("More rows match than one push covers — re-run after this one to continue.");
+    }
+    const mapping = recordValue(data.field_mapping);
+    const mapped = Object.entries(mapping).map(([field, column]) => `${field}=${String(column)}`);
+    lines.push(`Mapping: ${mapped.length > 0 ? mapped.join(", ") : "none detected"}`);
+    const column = recordValue(data.column);
+    if (stringValue(column.key)) {
+        lines.push(`Provenance column: ${stringValue(column.key)}${column.exists === true ? "" : " (will be created)"}`);
+    }
+    const samples = Array.isArray(data.sample_leads) ? data.sample_leads : [];
+    if (samples.length > 0) {
+        lines.push("Sample leads (exactly as they will be sent):");
+        for (const sample of samples)
+            lines.push(`  ${JSON.stringify(sample)}`);
+    }
+    if (stringValue(data.dedupe))
+        lines.push(`Dedupe: ${stringValue(data.dedupe)}`);
+    const candidates = Array.isArray(campaign.candidates) ? campaign.candidates.filter(isRecord) : [];
+    if (candidates.length > 0) {
+        lines.push("Campaigns on this connection:");
+        for (const entry of candidates) {
+            lines.push(`  ${stringValue(entry.name) ?? "?"} (${stringValue(entry.id) ?? "?"}${stringValue(entry.status) ? `, ${stringValue(entry.status)}` : ""})`);
+        }
+    }
+    const blockedBy = Array.isArray(data.blocked_by) ? data.blocked_by.filter((entry) => typeof entry === "string") : [];
+    if (blockedBy.length > 0)
+        lines.push(`Blocked: ${blockedBy.join(", ")}`);
+    if (stringValue(data.note))
+        lines.push(stringValue(data.note));
+    const run = recordValue(data.run);
+    if (stringValue(run.id))
+        lines.push(`Run: ${stringValue(run.id)} (${stringValue(run.status) ?? "queued"})`);
+    if (stringValue(data.next_action))
+        lines.push(`Next: ${stringValue(data.next_action)}`);
+    const link = stringValue(data.web_url) ?? stringValue(data.deepLink);
+    if (link)
+        lines.push(link);
+    return `${lines.join("\n")}\n`;
+}
 function formatSequenceListHealth(data) {
     const sequences = Array.isArray(data.sequences) ? data.sequences.filter(isRecord) : [];
     const lines = [...formatSequenceFleetSummary(data.fleet), ""];
@@ -23221,6 +24516,122 @@ function formatSequenceListHealth(data) {
         lines.push(listLink);
     return `${lines.join("\n")}\n`;
 }
+/**
+ * Render one funnel metric.
+ *
+ * `numberText` defaults a missing value to "0", which is exactly the lie this
+ * whole contract exists to stop: a campaign whose workspace has no verified
+ * tracking domain would print "0" opens, indistinguishable from "nobody opened
+ * it". An unmeasured metric carries a coverage entry and prints what it is.
+ */
+function funnelMetricText(funnel, metric) {
+    const value = numericValue(funnel[metric]);
+    if (value !== null)
+        return String(value);
+    const coverage = recordValue(recordValue(funnel.coverage)[metric]);
+    const state = stringValue(coverage.state);
+    if (state === "not_supported")
+        return "n/a";
+    if (state)
+        return "not tracked";
+    return "—";
+}
+function funnelRateText(funnel, rate, metric) {
+    const value = numericValue(funnel[rate]);
+    if (value !== null)
+        return `${(value * 100).toFixed(1)}%`;
+    const coverage = recordValue(recordValue(funnel.coverage)[metric]);
+    const state = stringValue(coverage.state);
+    if (state === "not_supported")
+        return "n/a";
+    if (state)
+        return "not tracked";
+    return "—";
+}
+/**
+ * The per-channel funnel block, shared by `sequences stats` and `sequences
+ * analytics`.
+ *
+ * `sequences analytics` printed no funnel at all before this, only operational
+ * health. A blind user eval run against dev asked exactly the question this
+ * answers -- "which channel got the most replies, and what is my reply rate on
+ * each" -- and had to open every campaign's stats block one by one and hand-sum
+ * the channels in prose, because no command grouped them.
+ */
+function formatSequenceChannelFunnels(funnels, replies) {
+    const byChannel = recordValue(funnels);
+    const channels = ["linkedin", "email", "whatsapp"].filter((channel) => isRecord(byChannel[channel]));
+    if (channels.length === 0)
+        return [];
+    const rows = channels.map((channel) => {
+        const funnel = recordValue(byChannel[channel]);
+        const invites = recordValue(funnel.invites);
+        return [
+            channel,
+            numberText(funnel.recipients),
+            numberText(funnel.sends),
+            numericValue(invites.sent) === null ? "n/a" : `${numberText(invites.accepted)}/${numberText(invites.sent)}`,
+            funnelMetricText(funnel, "delivered"),
+            funnelMetricText(funnel, "opened"),
+            funnelMetricText(funnel, "replied"),
+            funnelRateText(funnel, "replyRate", "replied"),
+            funnelMetricText(funnel, "positiveReplied"),
+        ];
+    });
+    const lines = ["", ...renderTextTable(["CHANNEL", "PEOPLE", "SENDS", "ACCEPTED", "DELIVERED", "OPENED", "REPLIED", "REPLY RATE", "POSITIVE"], rows)];
+    // Name the remedy once per distinct gap rather than once per row.
+    const remedies = new Map();
+    for (const channel of channels) {
+        const coverage = recordValue(recordValue(byChannel[channel]).coverage);
+        for (const entry of Object.values(coverage)) {
+            const record = recordValue(entry);
+            if (stringValue(record.state) === "not_supported")
+                continue;
+            const detail = stringValue(record.detail);
+            const command = stringValue(recordValue(record.remedy).command);
+            if (detail)
+                remedies.set(detail, command ?? "");
+        }
+    }
+    for (const [detail, command] of remedies) {
+        lines.push(command ? `Not tracked: ${detail} Turn it on with: ${command}` : `Not tracked: ${detail}`);
+    }
+    // A reply can exist on a channel the table has no row for: an invite-only
+    // campaign whose lead answered the invite note replied on LinkedIn without ever
+    // being MESSAGED, so it is not in that channel's rate denominator. Left
+    // unexplained, the headline ("linkedin 19") disagrees with the table (18) and
+    // the reader has to guess -- a blind user eval hit exactly this and recorded it
+    // as plausible but unverified.
+    const byChannelReplies = recordValue(recordValue(replies).byChannel);
+    for (const channel of ["linkedin", "email", "whatsapp"]) {
+        const counted = numericValue(byChannelReplies[channel]) ?? 0;
+        const inTable = numericValue(recordValue(byChannel[channel]).replied) ?? 0;
+        const outside = counted - inTable;
+        if (outside <= 0)
+            continue;
+        lines.push(`${channel}: ${outside} more ${outside === 1 ? "reply" : "replies"} came from a campaign with no message step `
+            + "(an invite note, say), so they are counted in the total above but have no reply rate here.");
+    }
+    return lines;
+}
+/** `Replies: 4 (linkedin 2 · email 1 · unattributed 1)` -- the one-line answer. */
+function formatSequenceReplyRollup(replies) {
+    const rollup = recordValue(replies);
+    const total = numericValue(rollup.total);
+    if (total === null)
+        return null;
+    const byChannel = recordValue(rollup.byChannel);
+    const parts = ["linkedin", "email", "whatsapp"]
+        .map((channel) => [channel, numericValue(byChannel[channel])])
+        .filter((entry) => entry[1] !== null && entry[1] > 0)
+        .map(([channel, value]) => `${channel} ${value}`);
+    const unattributed = numericValue(rollup.unattributed) ?? 0;
+    // An unattributed reply is a recording gap made visible, never folded into a
+    // channel and never dropped.
+    if (unattributed > 0)
+        parts.push(`unattributed ${unattributed}`);
+    return parts.length > 0 ? `Replies: ${total} (${parts.join(" · ")})` : `Replies: ${total}`;
+}
 function formatSequenceStatsHealth(data) {
     const stats = recordValue(data.stats);
     const operational = recordValue(stats.operational);
@@ -23236,13 +24647,22 @@ function formatSequenceStatsHealth(data) {
     if (failureMix !== "—")
         lines.push(`Failure mix: ${failureMix}`);
     lines.push(...formatActionKindBreakdown(operational.failureAnalytics));
-    lines.push("", ...renderTextTable(["FUNNEL", "COUNT"], [
-        ["Enrolled", numberText(stats.enrolled)],
-        ["Invites sent", numberText(stats.invitesSent ?? stats.connectionRequestsSent)],
-        ["Connected", numberText(stats.connected ?? stats.connectionRequestsAccepted)],
-        ["Messages sent", numberText(stats.messagesSent)],
-        ["Replies", numberText(stats.totalReplies ?? stats.replied)],
-    ]));
+    lines.push("", `Enrolled: ${numberText(stats.enrolled)}`);
+    const replyLine = formatSequenceReplyRollup(stats.replies);
+    if (replyLine)
+        lines.push(replyLine);
+    const funnelLines = formatSequenceChannelFunnels(stats.funnels, stats.replies);
+    if (funnelLines.length > 0) {
+        lines.push(...funnelLines);
+    }
+    else {
+        lines.push("", ...renderTextTable(["FUNNEL", "COUNT"], [
+            ["Invites sent", numberText(stats.invitesSent ?? stats.connectionRequestsSent)],
+            ["Connected", numberText(stats.connected ?? stats.connectionRequestsAccepted)],
+            ["Messages sent", numberText(stats.messagesSent)],
+            ["Replies", numberText(stats.totalReplies ?? stats.replied)],
+        ]));
+    }
     const link = stringValue(data.web_url) ?? stringValue(data.deepLink);
     if (link)
         lines.push("", link);
@@ -23264,8 +24684,13 @@ function formatSequenceAnalyticsHealth(data) {
         `Selected-window outcomes: ${formatSequenceFailureTotals(failureAnalytics)}`,
         `Failure mix: ${formatCountRecord(recordValue(recordValue(failureAnalytics).byFailureClass))}`,
         ...formatActionKindBreakdown(failureAnalytics),
-        "",
     ];
+    const totals = recordValue(analytics.totals);
+    const replyLine = formatSequenceReplyRollup(totals.replies);
+    if (replyLine)
+        lines.push(replyLine);
+    lines.push(...formatSequenceChannelFunnels(totals.funnels, totals.replies));
+    lines.push("");
     if (sequences.length === 0) {
         lines.push("No sequences in this analytics scope.");
     }
@@ -23300,9 +24725,16 @@ function formatSequenceFleetSummary(value) {
     if (Object.keys(fleet).length === 0)
         return ["Fleet counts: unavailable (legacy API response)"];
     const states = recordValue(fleet.byOperationalState);
+    // Only when there is something to act on: a workspace with no parked drafts
+    // should not read a line of zeroes every time it lists its sequences.
+    const neverStarted = typeof fleet.neverStarted === "number" ? fleet.neverStarted : 0;
+    const parkedLeads = typeof fleet.neverStartedEnrollments === "number" ? fleet.neverStartedEnrollments : 0;
     return [
         `Fleet: ${numberText(fleet.markedActive)} marked active · ${numberText(fleet.operationallyLive)} operationally live · ${numberText(fleet.total)} total`,
         `States: ${SEQUENCE_OPERATIONAL_STATE_ORDER.map((state) => `${state} ${numberText(states[state])}`).join(" · ")}`,
+        ...(neverStarted > 0
+            ? [`Never started: ${numberText(neverStarted)} draft${neverStarted === 1 ? "" : "s"} holding ${numberText(parkedLeads)} enrolled lead${parkedLeads === 1 ? "" : "s"} — these send nothing until launched. List them with \`oxygen sequences list --operational-state never_started\`, then check one with \`oxygen sequences get <sequence> --readiness\` (read-only).`]
+            : []),
     ];
 }
 function formatSequenceOpenWork(value) {
@@ -26025,14 +27457,28 @@ catch (error) {
             if (hint)
                 process.stderr.write(`${hint}\n`);
         }
+        // `error: unknown option '--filter'` on `tables query` got no suggestion
+        // either (blind user eval, 2026-09-18): commander caps its suggester at
+        // three edits, and `--filter-json` is five away.
+        if (error.code === "commander.unknownOption") {
+            const hint = unknownOptionHint(program, cliArgs, error.message);
+            if (hint)
+                process.stderr.write(`${hint}\n`);
+        }
         if (error.code === "commander.excessArguments" &&
             cliArgs[0] === "skills" &&
             cliArgs[1] === "install") {
             const requestedSkill = cliArgs[2]?.trim() ?? "";
+            // A stray path is almost always `--project .`: the flag is a boolean that
+            // already means "this directory", so the hint must say that rather than
+            // offer a --skill name (blind baseline, 2026-09-19).
+            const looksLikePath = requestedSkill === "." || requestedSkill === ".." || /^[.~]?\//.test(requestedSkill);
             const skillArgument = /^[a-z0-9][a-z0-9_-]*$/i.test(requestedSkill)
                 ? requestedSkill
                 : "<name>";
-            process.stderr.write(`Hint: skill names use the --skill option. Did you mean \`${program.name()} skills install --skill ${skillArgument}\`?\n`);
+            process.stderr.write(looksLikePath
+                ? `Hint: --project takes no value; it installs into the current directory. Did you mean \`${program.name()} skills install --project\`?\n`
+                : `Hint: skill names use the --skill option. Did you mean \`${program.name()} skills install --skill ${skillArgument}\`?\n`);
         }
         process.exitCode = error.exitCode;
     }