@oxygen-agent/cli 1.1011.681 → 1.1011.767

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.1011.681
+Version: 1.1011.767

package/dist/column-run-notices.js

@@ -33,9 +33,11 @@ export function formatAiPromptPreviewNotice(data) {
     const state = isRecord(preview.state) && isRecord(preview.state.row)
         ? JSON.stringify(preview.state.row, null, 2)
         : null;
+    const searchQuery = readRecordString(preview, "search_query");
     return [
         `prompt preview — row ${rowId} (${source}), before grounding${truncation}:`,
         shown,
+        ...(searchQuery ? [`web search query for this row: ${searchQuery}`] : []),
         ...(state ? [`row values sent separately in classification state:\n${state.slice(0, 4000)}${state.length > 4000 ? "… (truncated)" : ""}`] : []),
     ].join("\n");
 }

package/dist/help.d.ts

@@ -55,5 +55,7 @@ export declare function commanderUsageFailure(program: Command, argv: readonly s
     envelope: CliFailure;
     exitCode: number;
 } | null;
+/** The command path argv resolves to, without the program name (`tables auto-run set`). */
+export declare function commandNameForArgv(program: Command, argv: readonly string[]): string;
 /** `--json` anywhere before a `--` terminator, where commander still reads options. */
 export declare function argvRequestsJson(argv: readonly string[]): boolean;

package/dist/help.js

@@ -414,6 +414,11 @@ export function commanderUsageFailure(program, argv, error, hint) {
         exitCode: exitCodeForErrorCode(code),
     };
 }
+/** The command path argv resolves to, without the program name (`tables auto-run set`). */
+export function commandNameForArgv(program, argv) {
+    const { path } = resolveCommandPath(program, argv);
+    return path.split(" ").slice(1).join(" ") || program.name();
+}
 /** `--json` anywhere before a `--` terminator, where commander still reads options. */
 export function argvRequestsJson(argv) {
     const end = argv.indexOf("--");

package/dist/index.js

@@ -9,6 +9,9 @@ import { WHATSAPP_ACCOUNT_FLAGS, whatsappAccountQuery } from "./whatsapp-account
 import { BILLING_OWNER_READ_CONTRACT } from "@oxygen/shared/contracts/billing-owner-read";
 import { publishingAmplificationListQueryContract, publishingAmplificationActionsQueryContract, publishingNotesQueryContract, publishingRevisionsQueryContract, publishingAnalyticsQueryContract, publishingReadQueryParams, } from "@oxygen/shared/contracts/publishing-reads";
 import { COPILOT_SESSIONS_LIST_CONTRACT } from "@oxygen/shared/contracts/copilot-sessions";
+import { SEQUENCE_ANALYTICS_READ_CONTRACT } from "@oxygen/shared/contracts/sequence-analytics-read";
+import { WORKFLOW_RUN_LIST_CONTRACT, workflowRunListQueryParams } from "@oxygen/shared/contracts/workflow-run-list";
+import { WORKFLOW_RUN_LIST_FLAG_OVERLAY, readWorkflowRunListFlags } from "./workflow-run-list-flags.js";
 import { registerCrmSupportFlags, readCrmNoteEditFields, readCrmPhotoFields, readCrmFileLabel, buildCrmObjectsPath, buildCrmConnectionsPath } from "./crm-support-flags.js";
 import { addToolCatalogSearchWindowFlag, readToolCatalogSearchWindow } from "./tool-catalog-search-window.js";
 import { createToolCatalogDetailCommand } from "./tool-catalog-detail-command.js";
@@ -31,7 +34,7 @@ import { registerVisualCommands } from "./visual-commands.js";
 import { renderPrimaryProviderBoard } from "./admin-primary-providers-render.js";
 import { registerFunctionsCommands } from "./functions-commands.js";
 import { STREAMED_FILE_IMPORT_MIN_BYTES, putImportFileStream, rowsForStreamedImportTarget, scanStreamedImportFile, shouldStreamFileImport, } from "./streamed-file-import.js";
-import { applyOxygenHelp, argvRequestsJson, commanderUsageFailure, enableCommandSuggestions, unknownCommandHint, unknownOptionHint, withoutHelpForUnknownCommand, validateRequiredOptionValues, } from "./help.js";
+import { applyOxygenHelp, argvRequestsJson, commanderUsageFailure, commandNameForArgv, enableCommandSuggestions, unknownCommandHint, unknownOptionHint, withoutHelpForUnknownCommand, validateRequiredOptionValues, } 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, 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, TAG_KINDS_PROSE, toFailure, workflowMcpToolName, } from "@oxygen/shared";
 import { PURCHASABLE_PLAN_KEYS, planVolumeBonusPercent, resolveBasePricingPlan } from "@oxygen/shared/billing";
@@ -49,6 +52,7 @@ import { INTEGRATION_CONNECT_ACCOUNT_CONTRACT } from "@oxygen/shared/contracts/i
 import { CRM_ENRICHMENT_READ_CONTRACT } from "@oxygen/shared/contracts/crm-enrichment-read";
 import { INBOX_DRAFTS_READ_CONTRACT } from "@oxygen/shared/contracts/inbox-drafts-read";
 import { SEQUENCE_LIST_PROJECTION_CONTRACT } from "@oxygen/shared/contracts/sequence-list";
+import { TABLE_LIST_QUERY_CONTRACT, tableListQueryParams } from "@oxygen/shared/contracts/table-list";
 import { buildSenderLimitsBody, parseWorkingDaysOption, SENDER_LIMITS_FLAG_OVERLAY } from "./sender-limits-flags.js";
 import { readColumnDecisionFlags } from "./column-decision-options.js";
 import { MANAGED_DATA_SUPPLIERS } from "@oxygen/shared/data-suppliers";
@@ -2036,6 +2040,7 @@ function buildCrmSetupBody(options) {
         objects: readCrmSetupObjects(options.objects),
         mode: resolveLiveDryRunMode(options),
         ...(options.withEnrichment === true ? { with_enrichment: true } : {}),
+        ...(options.withoutEnrichment === true ? { without_enrichment: true } : {}),
         ...(readOption(options.project) ? { project: readOption(options.project) } : {}),
     };
 }
@@ -5716,9 +5721,10 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .command("crm")
         .description("Agent-native CRM object setup, records, automatic enrichment, and metadata commands. Who to contact first today: crm signals leads-today lists people ranked by their strongest intent signal in the last 7 days (website visit > profile view > post reaction > new follower), most recent first within a type.")
         .addCommand(new Command("setup")
-        .description("Create or repair standard CRM object-backed tables. Defaults to dry-run.")
+        .description("Create or repair standard CRM object-backed tables; defaults to dry-run. A live run that creates the companies or people list also switches on automatic paid enrichment for every record added later: the dry run says what it costs, and --without-enrichment skips it.")
         .option("--objects <objects>", "Comma-separated standard CRM objects to set up. Defaults to companies,people,deals.")
         .option("--project <project>", "Project id or slug for created CRM tables.")
+        .option("--without-enrichment", "Set up the lists without switching on automatic enrichment, not even on a freshly created table. Wins over --with-enrichment. Switch an enrichment on later with `oxygen crm enrichment enable`.")
         .option("--with-enrichment", "Also arm the standing cheap-enrichment auto-run on objects that already existed (fresh-created tables arm it by default). New records then auto-enrich within the per-batch credit cap, whether they arrive by import, insert, upsert, or `crm assert`. If your plan runs fewer columns per record than the defaults, the columns left out are listed under autoRunColumnsOverLimit. Pick which enrichments run with `oxygen crm enrichment`.")
         .option("--dry-run", "Preview CRM setup without creating or repairing tables.")
         .option("--live", "Apply CRM setup changes. Default is dry-run.")
@@ -5877,7 +5883,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. 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("--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; a value for one is left out and reported in `warnings`. 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.")
@@ -7104,29 +7110,20 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .action(async (options) => {
         await handleAsyncAction("tables import-bundle", options, () => importTableBundle(options, binaryName));
     }))
-        .addCommand(new Command("list")
-        .description("List workspace tables in the current tenant database.")
-        .option("--project <project>", "Project id or slug to filter by.")
-        .option("--tag <tag>", "Only tables carrying this workspace tag (see `oxygen tags list`).")
-        .option("--include-archived", "Also list archived, delete-scheduled and purging tables (the trash; each carries a lifecycle with purge_scheduled_at, and one with purgeStartedAt is being purged and can no longer be restored).")
-        .option("--limit <n>", "Maximum tables to list. Defaults to 200; hard cap is 1000.")
+        .addCommand(addContractFlags(new Command("list").description("List workspace tables in the current tenant database."), TABLE_LIST_QUERY_CONTRACT, {
+        project: { help: "Project id or slug to filter by." },
+        tag: { help: "Only tables carrying this workspace tag (see `oxygen tags list`)." },
+        include_archived: {
+            help: "Also list archived, delete-scheduled and purging tables (the trash; each carries a lifecycle with purge_scheduled_at, and one with purgeStartedAt is being purged and can no longer be restored).",
+        },
+        limit: { help: "Maximum tables to list. Defaults to 200; hard cap is 1000.", valueName: "<n>" },
+    })
         .option("--all", "List every table instead of the newest window.")
         .option("--json", "Print a JSON envelope.")
-        .addHelpText("after", "\nLists the 200 newest tables by default; `returned` in the JSON envelope is the count in this response and `capped` says when there are more (pass --all for every table). Per-folder totals live on `oxygen projects list` (`tableCount`). `oxygen workspace map --kind table --query <text>` finds a recent table by name but searches only the 200 newest tables (its `capped` says when older ones were not searched); to match a name across every table, read `oxygen tables list --all --json`.\n")
+        .addHelpText("after", "\nLists the 200 newest tables by default. Follow nextCursor with --cursor and the same filters, or pass --all. --query searches names across every table; --projection summary keeps results compact. rowCount is null when not reconciled; measure unknown counts with `tables describe <table> --stats`.\n")
         .action(async (options) => {
         await handleAsyncAction("tables list", options, async () => {
-            const params = new URLSearchParams();
-            const project = readOption(options.project);
-            if (project)
-                params.set("project", project);
-            const tag = readOption(options.tag);
-            if (tag)
-                params.set("tag", tag);
-            if (options.includeArchived)
-                params.set("include_archived", "true");
-            const limit = readPositiveInt(options.limit);
-            if (limit !== undefined)
-                params.set("limit", String(limit));
+            const params = tableListQueryParams(readContractFlags(options, TABLE_LIST_QUERY_CONTRACT));
             if (options.all)
                 params.set("all", "true");
             const qs = params.toString() ? `?${params.toString()}` : "";
@@ -7134,7 +7131,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
             // 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)", "find one by name with `workspace map --kind table --query <text>`");
+                writeListCapNotice(data, "table(s)", "continue with --cursor <nextCursor>, or find a name with --query <text>");
             return data;
         });
     }))
@@ -7229,6 +7226,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         .argument("<table>", "Table id or slug.")
         .option("--include-archived", "Include archived columns, and read a table that is archived, scheduled for deletion or being purged.")
         .option("--stats", "Include stats.rowCount (also summary.rowCount) and per-column fill rates. Row count is exact; above 100 rows fill rates use a 100-row sample (stats.statsSampled). 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.")
+        .option("--column <key>", "Describe just this one column (its kind, definition and whether auto-run includes it) instead of every column.")
         .option("--json", "Print a JSON envelope.")
         .action(async (table, options) => {
         await handleAsyncAction("tables describe", options, () => requestOxygen("/api/cli/tables/describe", {
@@ -7237,6 +7235,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
                 table,
                 ...(options.includeArchived ? { include_archived: true } : {}),
                 ...(options.stats ? { include_stats: true } : {}),
+                ...(readOption(options.column) ? { column: readOption(options.column) } : {}),
             },
         }));
     }))
@@ -9472,7 +9471,12 @@ Examples:
     ].join("\n"));
     program
         .command("recipes")
-        .description("GTM plays: proven motions with prerequisites, credit posture, and approval gates spelled out, to borrow from and adapt. To design a motion for your company, use the oxygen-gtm-consultant skill: oxygen skills get oxygen-gtm-consultant --json.")
+        // Customers meet these as "plays" (the web app's Plays page and every
+        // copied play prompt), so that is the noun their agent types first. A
+        // production audit on 2026-10-04 saw all 33 blind runs open with
+        // `oxygen plays` and lose a call to "unknown command".
+        .alias("plays")
+        .description("GTM plays: proven motions with prerequisites, credit posture, and approval gates spelled out, to borrow from and adapt. Alias: `plays`. To design a motion for your company, use the oxygen-gtm-consultant skill: oxygen skills get oxygen-gtm-consultant --json.")
         .addCommand(new Command("list")
         .description("Find a GTM play for a goal: recipes ranked by relevance to your words; --view summary for a compact index. Filter by business-case category, journey stage, or audience.")
         .argument("[query]", "Your goal in plain words, e.g. \"more pipeline from linkedin\" (ranked against title, trigger phrases, tags, and business case).")
@@ -11049,13 +11053,13 @@ Examples:
         .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.")
+        .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. For the companies in a table you already have, sample them free with people search preview --from-table <table> --linkedin-url-column <key>, then people search plan|run --from-table to search each company and write 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. To see the people at specific companies for free, put their LinkedIn company URLs in company.linkedin_url. Then people search run --source people_search --source-filters-json <same filters> for a quoted, approved table fill; people search run --from-table instead runs one paid search per company in a table and covers each one.")
+        .description("Preview up to 50 people free, using native filters from people search filters. For the companies in one of your tables, pass --from-table with --linkedin-url-column; for a few named companies, put their LinkedIn company URLs in company.linkedin_url. Then people search run --source people_search --source-filters-json <same filters> for a quoted, approved table fill; people search run --from-table instead runs one paid search per company in a table and 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("--from-table <table>", "Free sample of Find decision makers at companies: search the first 50 companies in this table in one free page. Pair with --linkedin-url-column.")
         .option("--linkedin-url-column <key>", "Column of --from-table that holds each company's LinkedIn URL.")
@@ -11389,7 +11393,7 @@ Examples:
     }))
         .addCommand(new Command("usage")
         .description("Show credit ledger events (each tagged with its FIXED/FLEXIBLE spend_class), workflow step usage (automation_actions: credits per step, credits billed; writing rows is free), calls with your own API keys (byok_calls: the platform fee per call and the fee credits this month; your provider bills the call itself), or connected LinkedIn and WhatsApp accounts (provider_seats: the rolling-30d peak and its implied Unipile cost; what each account is charged is its credit reservation in `billing commitments`). On a plan that pays for several workspaces (an agency covering client workspaces), `--group-by workspace` totals the credits each workspace spent (`by_workspace`) and `--workspace <id|slug>` narrows the ledger to one of them; a linked client workspace sees only its own spend.")
-        .option("--meter <meter>", "credits, automation_actions, byok_calls, or provider_seats (rolling-30d peak connected accounts and implied Unipile COGS; the per-account charge is listed by `billing commitments`). Defaults to credits.")
+        .option("--meter <meter>", "credits, automation_actions, byok_calls, or provider_seats (rolling-30d peak connected accounts and the flat per-account charge; each account's reservation is listed by `billing commitments`). Defaults to credits.")
         .option("--days <n>", "Lookback window in days. Defaults to 30.")
         .option("--from <iso>", "Only include ledger events at or after this ISO timestamp.")
         .option("--to <iso>", "Only include ledger events at or before this ISO timestamp.")
@@ -13670,7 +13674,7 @@ Examples:
         await handleAsyncAction("senders checkpoints", options, () => requestOxygen("/api/cli/senders/checkpoints"));
     }))
         .addCommand(new Command("connect")
-        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). This command creates a pending provider authorization; it does not preview a price. Each connected LinkedIn account has one monthly charge, never two: an existing dollar seat until it ends at renewal, or a monthly credit reservation after seats retire. On a repriced workspace that reservation is 3,400 credits ($34) monthly; a connect the balance cannot cover fails with insufficient_credits. Invites, messages and other LinkedIn actions cost 0 credits on top. Check `oxygen billing seats --json` before connecting for the current charge and seat status. A workspace linked to another organization's plan is billed at that organization. New accounts require --country (the owner's normal LinkedIn login country) and default to syncing only conversations OXYGEN starts; use --inbox-scope all to opt into the full LinkedIn inbox. Use --cookie-auth and --custom-proxy to expose those inputs inside Unipile's hosted wizard; their secrets never pass through OXYGEN. Use --count for bulk onboarding; --count above 1 needs --owner-consent (each owner connects their own account). Links are shareable and valid for 10 minutes.")
+        .description("Get a Unipile hosted-auth URL to connect a new LinkedIn account (or reconnect with --reconnect). This command creates a pending provider authorization; it does not preview a price. Each connected LinkedIn account has one monthly charge, never two: an existing dollar seat until it ends at renewal, or a monthly credit reservation after seats retire. Once the workspace is repriced that reservation is 3,400 credits ($34) monthly; a connect the balance cannot cover fails with insufficient_credits. Invites, messages and other LinkedIn actions cost 0 credits on top. `oxygen billing seats --json` reports the charge that applies to this workspace now, and `oxygen billing estimate --linkedin-accounts <n> --json` prices n accounts against your plan. A workspace linked to another organization's plan is billed at that organization. New accounts require --country (the owner's normal LinkedIn login country) and default to syncing only conversations OXYGEN starts; use --inbox-scope all to opt into the full LinkedIn inbox. Use --cookie-auth and --custom-proxy to expose those inputs inside Unipile's hosted wizard; their secrets never pass through OXYGEN. Use --count for bulk onboarding; --count above 1 needs --owner-consent (each owner connects their own account). Links are shareable and valid for 10 minutes.")
         .option("--reconnect <connection_id>", "Reconnect an existing connection instead of creating a new one. Accepts a connection id.")
         .option("--country <code>", "Required for new accounts: ISO 3166-1 alpha-2 code for the account owner's normal LinkedIn login country (for example DE or US).")
         .option("--sales-nav", "Request Classic + Sales Navigator access during Unipile hosted authentication.")
@@ -15857,35 +15861,39 @@ Examples:
             });
         });
     })))
-        .addCommand(new Command("analytics")
+        .addCommand(addContractFlags(new Command("analytics")
         .description("Show selected-window sequencer analytics with persisted status kept separate from operational state, fleet marked-active versus operationally-live counts, current open work, sent/terminal-failed/deferral totals, failure classes, and action-kind breakdowns. Also includes per-sequence funnels and native email attribution under analytics.emailAttribution: byMailbox, byDomain, and explicit unattributed facts. With --sequence, analytics.senderPerformance groups channel-conditional counts and rates by sending person; analytics.messagePerformance reports each copy-bearing deterministic step variant, target/actual distribution, contacted recipients, and type-specific accepted/reply/positive outcomes (absent for note-less connect-only campaigns). Message-level reply outcomes require preserved step/variant provenance, so older unattributed replies remain in campaign totals without being guessed into a message row. Provider-owned campaigns appear only after their telemetry is normalized into Oxygen's native Sequence ledgers. Also reports whether the reply → CRM automation is armed, with a link to the workflow.")
-        .option("--range <range>", "Preset range: 7d, 14d, 28d, 30d, 90d, 180d, 365d, or all. Defaults to 14d. `all` starts at the oldest campaign in scope.")
-        .option("--from <date>", "Custom start date (YYYY-MM-DD). Windows up to five years are accepted.")
-        .option("--to <date>", "Custom end date (YYYY-MM-DD).")
-        .option("--sequence <id-or-slug>", "Limit analytics to one sequence.")
-        .option("--sender <key>", "A sender from `oxygen senders list` or `oxygen senders profiles list`, or a key from this output's senders list. Repeatable.", collectRepeatable, [])
-        .option("--json", "Print a JSON envelope.")
+        .option("--sender <id>", "Filter to one sender from `oxygen senders list` or `oxygen senders profiles list`, or a key from this output's senders list. Repeatable.", collectRepeatable, [])
+        .option("--json", "Print a JSON envelope."), SEQUENCE_ANALYTICS_READ_CONTRACT, {
+        range: { valueName: "<preset>", parse: readOption },
+        from: { valueName: "<date>", parse: readOption }, to: { valueName: "<date>", parse: readOption },
+        sequence: { valueName: "<sequence>", parse: readOption },
+        campaigns: { valueName: "<ids>", parse: readOption }, senders: { valueName: "<ids>", parse: readOption },
+    })
         .action(async (options) => {
-        await handleReadActionWithLens("sequences analytics", options, () => {
-            const params = new URLSearchParams();
-            const range = readOption(options.range);
-            const from = readOption(options.from);
-            const to = readOption(options.to);
-            const sequence = readOption(options.sequence);
-            const senders = (options.sender ?? []).flatMap((value) => readCsvOption(value));
-            if (range)
-                params.set("range", range);
-            if (from)
-                params.set("from", from);
-            if (to)
-                params.set("to", to);
-            if (sequence)
-                params.set("sequence", sequence);
+        const fetchAnalytics = () => {
+            const query = readContractFlags(options, SEQUENCE_ANALYTICS_READ_CONTRACT, {
+                range: { parse: readOption }, from: { parse: readOption }, to: { parse: readOption },
+                sequence: { parse: readOption }, campaigns: { parse: readOption }, senders: { parse: readOption },
+            });
+            const senders = [...readCsvOption(typeof query.senders === "string" ? query.senders : undefined), ...(options.sender ?? []).flatMap(value => readCsvOption(value))];
             if (senders.length > 0)
-                params.set("senders", senders.join(","));
+                query.senders = senders.join(",");
+            else
+                delete query.senders;
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined && value !== null)
+                    params.set(key, String(value));
+            }
             const qs = params.toString();
             return requestOxygen(`/api/cli/sequences/analytics${qs ? `?${qs}` : ""}`);
-        }, formatSequenceAnalyticsHealth);
+        };
+        const windowRequested = ["projection", "path", "valueCursor", "maxChars"].some(key => options[key] !== undefined);
+        if (windowRequested)
+            await handleAsyncAction("sequences analytics", options, fetchAnalytics);
+        else
+            await handleReadActionWithLens("sequences analytics", options, fetchAnalytics, formatSequenceAnalyticsHealth);
     }))
         .addCommand(new Command("create")
         .description("Create a draft multichannel sequence from a steps JSON file. Supports LinkedIn, email, WhatsApp, human call_task, and connected-CRM crm_task journeys. Assign LinkedIn senders with --senders (optional at create — a draft can sit senderless, but enroll/start require at least one for LinkedIn journeys). Native email sends through connected Google/Microsoft mailboxes, including Microsoft SMTP transport; optional --email-* flags bind an Instantly campaign. Install/read the oxygen-sequencer skill for per-step senders (references/email.md, references/linkedin.md), the launch ladder and complete mapped CRM task examples (references/calls-and-crm-tasks.md).")
@@ -15895,6 +15903,7 @@ Examples:
         .requiredOption("--steps-file <path>", "Path to a JSON file: { \"steps\": [...] }. LinkedIn steps (visit_profile | invite | wait_for_connection | message | inmail | follow | like_post | comment_post | withdraw_invite), email steps (email_send | email_enroll | email_move | email_stop), WhatsApp (whatsapp_message), human call tasks (call_task), connected-CRM tasks (crm_task; channel crm; exact identity record_mappings + explicit create/update policy + record_links + dynamic task property_mappings/associations), and control steps (wait | wait_for_signal | branch | stop), each with an `id`. Copy templates support {{column}} interpolation from the lead's row, {{column|fallback}} inline fallbacks, deterministic spintax — {{RANDOM|a|b|c}} or industry-standard bare {Hi|Hey|Hello}, nestable like {Would {Tuesday|Thursday} work|next week?} — and {% if column %}…{% endif %} conditionals; a bare {…} region is spintax only when it contains a top-level |, so literal braces (CSS/JSON) pass through. Every step's copy can also use {{sender_first_name}}, {{sender_last_name}} and {{sender_full_name}} (alias {{sender_name}}): the name of the person who sends that step (their sender profile, else the account or inbox display name), with no table column needed; email steps add {{sender_email}} (the from address). A row column of the same name WINS on collision, and a missing name renders empty. comment_post takes text_template and/or ai_prompt — a KG-grounded comment generated at send time (a paid AI call) that falls back to text_template if generation fails. A `branch` routes on signals (then/else) or the legacy connection_accepted/already_connected/open_profile sugar (then_id/else_id). A signal condition can also branch on the LEAD'S DATA: a data leaf { has_column: \"email\" } is true when that row_values column has a non-empty value (add present:false for \"missing\") — e.g. route leads that have an email down an email arm and the rest down a LinkedIn arm. MINIMAL EMAIL STEP SHAPE: { \"id\": \"s1\", \"channel\": \"email\", \"kind\": \"email_send\", \"subject_template\": \"...\", \"body_template\": \"...\" } — body_template is REQUIRED on email_send; subject_template is OPTIONAL and is the one control that decides threading: give a step its own subject and it goes out as a NEW email, omit it and the step continues the lead's previous email in the same thread, going out as \"Re: <the previous email's subject>\" (what the retired email_reply kind used to be — still accepted on input, rewritten into this shape, and reported under `warnings` in the response). The FIRST email step of a sequence must carry a subject, since it has no earlier thread to continue. MINIMAL WHATSAPP STEP SHAPE: { \"id\": \"s1\", \"channel\": \"whatsapp\", \"kind\": \"whatsapp_message\", \"template\": \"Hi {{first_name|there}} …\" } — template is REQUIRED, and a live WhatsApp start also needs the sequence's --whatsapp-cold-initiate opt-in. MINIMAL WAIT STEP SHAPE: { \"id\": \"w1\", \"kind\": \"wait\", \"days\": 3 } — days and/or hours, at least 1 hour in total. A/B tests use an explicit `variants` array of copy partials on the step (up to 25 alternates, a–z; spintax varies wording INSIDE one variant and is not A/B-tracked). For the complete replay-safe crm_task upsert mapping shape, read `oxygen skills get oxygen-sequencer --file references/calls-and-crm-tasks.md`.")
         .option("--channels <list>", "Comma-separated channels: linkedin,email,whatsapp,call,crm. Defaults to the channels the journey touches. crm_task currently supports HubSpot.")
         .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.")
+        .addOption(new Option("--whatsapp-duplicate-scope <scope>", "Prevent duplicate WhatsApp copy in this campaign (default) or all campaigns.").choices(["campaign", "workspace"]))
         .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; `senders list` / `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 or slug whose rows supply {{column}} template values.")
@@ -16015,6 +16024,7 @@ Examples:
         .option("--steps-file <path>", "Draft only: path to a JSON file: { \"steps\": [...] } replacing the journey. Copy supports {{column}} interpolation; every step also takes {{sender_first_name}} / {{sender_last_name}} / {{sender_full_name}} for the person who sends it, and email adds {{sender_email}} (a same-named row column wins). A `branch` can also route on the lead's data with a data leaf { has_column: \"email\" } (true when that row_values column is non-empty; present:false for \"missing\").")
         .option("--channels <list>", "Draft only: comma-separated channels: linkedin,email,whatsapp,call,crm.")
         .option("--whatsapp-cold-initiate", "WhatsApp: allow cold-initiating new chats (no prior conversation). Required to start a WhatsApp sequence live (draft-editable).")
+        .addOption(new Option("--whatsapp-duplicate-scope <scope>", "Prevent duplicate WhatsApp copy in this campaign (default) or all campaigns.").choices(["campaign", "workspace"]))
         .option("--phone-column-key <key>", "WhatsApp: row_values key holding each lead's phone number (else falls back to phone/phone_number/mobile).")
         .option("--email-column-key <key>", "Native email: row_values key holding each lead's email (else falls back to email/email_address/work_email). Maps a non-English header (e.g. E-Mail).")
         .option("--linkedin-url-column-key <key>", "LinkedIn: row_values key holding each lead's profile URL (else falls back to linkedin_url/linkedinUrl/linkedin/profile_url). \"\" clears it back to auto-detect.")
@@ -16136,7 +16146,7 @@ Examples:
         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. An active sequence contacts the new leads on its next dispatch tick; a draft or paused one holds them until `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`.")
+        .description("Enroll leads into a sequence. Enrolling spends no credits. An active sequence contacts the new leads on its next dispatch tick; a draft or paused one holds them until `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). WhatsApp-only campaigns also enroll each normalized number once across all source rows and enrollment statuses; mixed campaigns keep other channels and skip duplicate WhatsApp actions. Duplicate protection defaults to this campaign; --whatsapp-duplicate-scope on create/update can additionally block identical copy across all campaigns. 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.")
@@ -17565,9 +17575,12 @@ Examples:
         .option("--locals <list>", "Comma-separated local parts to create for --sender, e.g. `--locals talia,talia.rosen,t.rosen` on send.acme.com orders talia@, talia.rosen@, and t.rosen@ — all owned by that one person. Requires --sender, because a bare local part carries no name and the vendor's stamp is permanent.")
         .option("--mailboxes <json>", "JSON array of mailboxes: [{\"username\",\"first_name\",\"last_name\",\"profile_picture_url\"}], or [{\"username\",\"sender_profile_id\"}] to take the identity from a sender profile per item (mix freely). profile_picture_url is optional and must be a PUBLIC, PERMANENT https URL — the vendor fetches it server-side at provisioning, so an expiring CDN link (e.g. a media.licdn.com URL with e=<epoch>) ships the mailbox faceless. Use `oxygen managed-inboxes upload-avatar <path>` to host one, or --sender / sender_profile_id, whose photo Oxygen already mirrors.")
         .option("--file <path>", "Path to a JSON file { \"mailboxes\": [...] } (alternative to --mailboxes).")
-        .addOption(new Option("--preview", "Explicit read-only quote: connects nothing, buys nothing and charges nothing. Cannot be combined with --approved.").conflicts("approved"))
+        .addOption(new Option("--preview", "Explicit read-only quote: connects nothing, buys nothing and charges nothing. Cannot be combined with purchase or DNS cleanup approval.").conflicts(["approved", "dnsCleanupApproved"]))
         .option("--existing-domain", "Use an existing Cloudflare domain from oxygen domains list; never register or transfer it.")
         .option("--max-per-domain <n>", "Save a stricter mailbox limit with the approved order, including existing addresses (e.g. 2). Preview does not save it.")
+        .option("--dns-cleanup-records <ids>", "Preview deletion of these comma-separated exact email DNS record IDs on an existing domain; connects and buys nothing.")
+        .addOption(new Option("--dns-cleanup-approved", "Delete only the reviewed email records; requires --dns-cleanup-records and --dns-cleanup-hash. Request a fresh purchase quote afterward.").conflicts("approved"))
+        .option("--dns-cleanup-hash <hash>", "The plan_hash from the exact DNS cleanup preview, required to delete records.")
         .option("--years <n>", "Years to register a new domain for (1-10). Omit for existing domains.")
         .option("--redirect-url <url>", "Where the domain's web root redirects. Defaults to your workspace's company website; editable later with `oxygen domains forwarding set`.")
         .option("--billing <path>", "Path to a JSON file with the registrant/WHOIS contact (first_name, last_name, phone, country, city, state, address_line_one, postal_code). Required on your FIRST order; later orders reuse the registrant already on file.")
@@ -17597,6 +17610,13 @@ Examples:
             const billingPath = readOption(options.billing);
             const billing = billingPath ? readJsonFileValue(resolve(billingPath), "--billing") : undefined;
             const quote = readOption(options.quote);
+            const cleanupRecords = readOption(options.dnsCleanupRecords);
+            const cleanupHash = readOption(options.dnsCleanupHash);
+            if ((cleanupRecords && !options.existingDomain)
+                || ((options.dnsCleanupApproved || cleanupHash) && !cleanupRecords)
+                || (options.dnsCleanupApproved && !cleanupHash)) {
+                throw new OxygenError("invalid_request", "DNS cleanup requires --existing-domain and --dns-cleanup-records; deletion also requires its fresh --dns-cleanup-hash.", { exitCode: 2 });
+            }
             return requestOxygen("/api/cli/managed-inboxes/subscribe", {
                 method: "POST",
                 body: {
@@ -17607,6 +17627,11 @@ Examples:
                     ...(years ? { years: Number(years) } : {}),
                     ...(options.existingDomain ? { existing_domain: true } : {}),
                     ...(options.maxPerDomain !== undefined ? { max_mailboxes_per_domain: Number(options.maxPerDomain) } : {}),
+                    ...(cleanupRecords ? { dns_cleanup: {
+                            record_ids: cleanupRecords.split(",").map((id) => id.trim()),
+                            approved: options.dnsCleanupApproved === true,
+                            ...(cleanupHash ? { plan_hash: cleanupHash } : {}),
+                        } } : {}),
                     ...(redirectUrl ? { redirect_url: redirectUrl } : {}),
                     ...(billing ? { billing } : {}),
                     // Warm-up is on unless --no-warmup. Placement is opt-in: it is sent only
@@ -19666,34 +19691,21 @@ Full trigger schema: oxygen workflows schema --subject trigger --json
             }), options);
         });
     })))
-        .addCommand(new Command("runs")
-        .description("List workflow runs.")
-        .option("--workflow <workflow>", "Workflow id, slug, or name.")
-        .option("--workflow-id <workflow_id>", "Workflow id or slug.")
-        .option("--status <status>", "Filter by queued, running, waiting, awaiting_approval, completed, failed, canceling, or canceled.")
-        .option("--mode <mode>", "Filter by execution mode: smoke_test, dry_run, or live.")
-        .option("--cursor <cursor>", "Continue from a previous page. Pass the nextCursor the last response returned.")
-        .option("--limit <n>", "Maximum runs to return. Defaults to 50.")
+        .addCommand(addContractFlags(new Command("runs")
+        .description("List stored workflow runs. Optional windows preserve complete public values without executing a workflow."), WORKFLOW_RUN_LIST_CONTRACT, WORKFLOW_RUN_LIST_FLAG_OVERLAY)
         .option("--include-bundle", "Include durable recipe bundles in JSON output.")
         .option("--json", "Print a JSON envelope.")
-        .addHelpText("after", "\nPaging is anchored to the exact last run of the previous page, so runs arriving while you page are never skipped or repeated. A null nextCursor means the history ended.\n")
+        .addHelpText("after", "\nFor complete bounded history use --projection summary/full; echo nextCursor with the same filters. Unqualified legacy reads issue a continuation only with an explicit --limit. Value windows require --run-id and reauthorize the exact filtered public row.\n")
         .action(async (options) => {
         await handleAsyncAction("workflows runs", options, async () => {
-            const query = new URLSearchParams();
-            const workflow = readOption(options.workflow) ?? readOption(options.workflowId);
-            if (workflow)
-                query.set("workflow", workflow);
-            if (readOption(options.status))
-                query.set("status", readOption(options.status) ?? "");
-            if (readOption(options.mode))
-                query.set("mode", readOption(options.mode) ?? "");
-            if (readOption(options.cursor))
-                query.set("cursor", readOption(options.cursor) ?? "");
-            const limit = readPositiveInt(options.limit);
-            if (limit)
-                query.set("limit", String(limit));
+            const args = readWorkflowRunListFlags(options);
+            const query = workflowRunListQueryParams(args);
             const suffix = query.toString() ? `?${query.toString()}` : "";
-            return prepareWorkflowCliOutput(await requestOxygen(`/api/cli/workflows/runs${suffix}`), options);
+            const data = await requestOxygen(`/api/cli/workflows/runs${suffix}`);
+            // Opt-in windows are lossless public native receipts. Legacy bundle
+            // stripping/error aliases still apply only to the unqualified read.
+            return ["projection", "path", "value_cursor", "max_chars"].some(key => args[key] !== undefined)
+                ? data : prepareWorkflowCliOutput(data, options);
         });
     }))
         .addCommand(new Command("failures")
@@ -22776,8 +22788,23 @@ function assertNotPeopleSearchKind(kind) {
         });
     }
 }
+// The id a `search plan` envelope prints (search_plan_…, company_search_plan_…,
+// signal_search_plan_…). `--plan` takes the plan itself, not its id; a blind
+// acceptance run on 2026-10-04 passed the id and got only "Input must be valid
+// JSON" with no way forward.
+const SEARCH_PLAN_ID_PATTERN = /^[a-z_]*search_plan_[A-Za-z0-9]+$/;
 function readSearchPlanJson(value) {
-    const parsed = parseJsonObject(readFileIfPresent(value));
+    const raw = readFileIfPresent(value);
+    if (raw === value && SEARCH_PLAN_ID_PATTERN.test(value.trim())) {
+        throw new OxygenError("invalid_json", `--plan takes the plan JSON returned by the plan command, not its id ${value.trim()}.`, {
+            details: {
+                plan_id: value.trim(),
+                next_step: "Re-run the plan command with --json and save its output to a file (for example plan.json), then pass --plan plan.json.",
+            },
+            exitCode: 1,
+        });
+    }
+    const parsed = parseJsonObject(raw);
     const data = parsed.data;
     return data && typeof data === "object" && !Array.isArray(data)
         ? data
@@ -22785,7 +22812,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 = "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. 1 credit 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_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. 1 credit 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 --from-table 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.";
@@ -27798,7 +27825,7 @@ function formatCrmEnrichment(data) {
     return lines.join("\n");
 }
 function pushCrmEnrichmentObject(lines, styles, view) {
-    lines.push("", `${styles.bold(`Automatic enrichment — ${view.object}`)}  ${view.enabled ? styles.green("on") : styles.dim("off")}`, `  ${styles.dim("Standing permission: records written to this object enrich automatically, with no per-record approval, bounded by the per-batch ceiling below.")}`, "");
+    lines.push("", `${styles.bold(`Automatic enrichment — ${view.object}`)}  ${formatCrmEnrichmentState(view, styles)}`, `  ${styles.dim("Standing permission: records written to this object enrich automatically, with no per-record approval, bounded by the per-batch ceiling below.")}`, "");
     const labelWidth = Math.max(...view.presets.map((preset) => preset.label.length), 0);
     const armed = new Set(view.presets.filter((preset) => preset.enabled).map((preset) => preset.id));
     for (const preset of view.presets) {
@@ -27820,7 +27847,10 @@ function pushCrmEnrichmentObject(lines, styles, view) {
     if (view.custom_columns.length > 0) {
         // A hand-tuned config carries columns no preset owns, so the per-record
         // figure above can be a floor rather than the bill.
-        const note = view.custom_columns_uncosted ? ` ${styles.yellow("(cost not included above)")}` : "";
+        // Uncosted only when one of them may bill; a formula needs no run and is free.
+        const note = view.custom_columns_uncosted
+            ? ` ${styles.yellow("(cost not included above)")}`
+            : ` ${styles.dim("(free: no run needed)")}`;
         lines.push(`  ${styles.dim("Extra".padEnd(summaryWidth))}   ${view.custom_columns.join(", ")}${note}`);
     }
     // The half the config alone cannot show: an armed set says nothing about the
@@ -27831,12 +27861,6 @@ function pushCrmEnrichmentObject(lines, styles, view) {
     if (backfillLine) {
         lines.push(`  ${styles.dim("Not enriched".padEnd(summaryWidth))}   ${backfillLine}`);
     }
-    if (view.custom_columns.length > 0) {
-        // A hand-tuned config carries columns no preset owns, so the per-record
-        // figure above can be a floor rather than the bill.
-        const note = view.custom_columns_uncosted ? ` ${styles.yellow("(cost not included above)")}` : "";
-        lines.push(`  ${styles.dim("Extra".padEnd(summaryWidth))}   ${view.custom_columns.join(", ")}${note}`);
-    }
     if (view.changed) {
         lines.push("", ...formatCrmEnrichmentChange(view.changed, styles));
     }
@@ -27882,9 +27906,23 @@ function pushCrmEnrichmentPreset(lines, styles, preset, labelWidth, armed) {
     }
 }
 function formatCrmEnrichmentCredits(credits, styles, unit) {
-    return credits === 0
-        ? styles.green("free")
-        : styles.yellow(`${credits.toLocaleString("en-US")} ${unit}`);
+    if (credits === 0)
+        return styles.green("free");
+    // "1 credits/record" read wrong in a blind pass (2026-10-04); the unit is
+    // "credits" or "credits/record", so singularize its leading word.
+    const label = credits === 1 ? unit.replace(/^credits\b/, "credit") : unit;
+    return styles.yellow(`${credits.toLocaleString("en-US")} ${label}`);
+}
+// "on" alone reads as "the enrichments listed below are on" even when every one
+// of them is off and only a hand-added column is armed.
+function formatCrmEnrichmentState(view, styles) {
+    if (!view.enabled)
+        return styles.dim("off");
+    const anyPreset = view.presets.some((preset) => preset.enabled);
+    if (!anyPreset && view.custom_columns.length > 0) {
+        return `${styles.green("on")} ${styles.dim("— your own columns only")}`;
+    }
+    return styles.green("on");
 }
 function formatCrmEnrichmentCeiling(view, styles) {
     if (view.max_credits === null)
@@ -27892,7 +27930,8 @@ function formatCrmEnrichmentCeiling(view, styles) {
     const source = view.max_credits_source === "explicit"
         ? "you set this"
         : "your plan's per-delivery default";
-    return `${view.max_credits.toLocaleString("en-US")} credits ${styles.dim(`(${source})`)}`;
+    const unit = view.max_credits === 1 ? "credit" : "credits";
+    return `${view.max_credits.toLocaleString("en-US")} ${unit} ${styles.dim(`(${source})`)}`;
 }
 function formatCrmEnrichmentSources(sources) {
     if (sources.length === 0)
@@ -29780,6 +29819,9 @@ function readSequenceSettings(options) {
     if (options.whatsappColdInitiate === true) {
         settings.whatsapp_cold_initiate = true;
     }
+    const whatsappDuplicateScope = readOption(options.whatsappDuplicateScope);
+    if (whatsappDuplicateScope)
+        settings.whatsapp_duplicate_scope = whatsappDuplicateScope;
     const phoneColumnKey = readOption(options.phoneColumnKey);
     if (phoneColumnKey) {
         settings.phone_column_key = phoneColumnKey;
@@ -29964,6 +30006,12 @@ catch (error) {
             writeJson(usage.envelope);
         process.exitCode = usage?.exitCode ?? error.exitCode;
     }
+    else if (error instanceof OxygenError) {
+        // An option a command reads before its handleAsyncAction (`tables auto-run
+        // set --max-credits 0` -> readPositiveNumber) throws outside every handler,
+        // and used to escape as a raw Node stack with no envelope, even with --json.
+        emitCliFailure(commandNameForArgv(program, argv.slice(2)), error);
+    }
     else {
         throw error;
     }

package/dist/workflow-run-list-flags.d.ts

@@ -0,0 +1,3 @@
+import { type ContractFlagOverlay } from "./contract-flags.js";
+export declare const WORKFLOW_RUN_LIST_FLAG_OVERLAY: ContractFlagOverlay;
+export declare function readWorkflowRunListFlags(options: Record<string, unknown>): Record<string, unknown>;

package/dist/workflow-run-list-flags.js

@@ -0,0 +1,21 @@
+import { WORKFLOW_RUN_LIST_CONTRACT } from "@oxygen/shared/contracts/workflow-run-list";
+import { readContractFlags } from "./contract-flags.js";
+import { readPositiveInt } from "./cli-values.js";
+import { readOption } from "./util.js";
+export const WORKFLOW_RUN_LIST_FLAG_OVERLAY = {
+    workflow: { valueName: "<workflow>", parse: readOption },
+    workflow_id: { valueName: "<workflow_id>", help: "Workflow id or slug; legacy CLI --workflow takes precedence.", parse: readOption },
+    status: { valueName: "<status>", parse: readOption },
+    mode: { valueName: "<mode>", parse: readOption },
+    cursor: { valueName: "<cursor>", parse: readOption },
+    // Preserve the shipped CLI parser: native HTTP owns the upper-500 refusal.
+    limit: { valueName: "<n>", parse: readPositiveInt },
+};
+export function readWorkflowRunListFlags(options) {
+    const args = readContractFlags(options, WORKFLOW_RUN_LIST_CONTRACT, WORKFLOW_RUN_LIST_FLAG_OVERLAY);
+    const workflow = args.workflow ?? args.workflow_id;
+    delete args.workflow_id;
+    if (workflow !== undefined)
+        args.workflow = workflow;
+    return args;
+}