@oxygen-agent/cli 1.1014.1464 → 1.1014.1597

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.1014.1464
+Version: 1.1014.1597

package/dist/command-families/program.js

@@ -76,6 +76,7 @@ import { registerSignupLeadsFamily } from "../commands/signup-leads.js";
 import { registerSkillsFamily } from "../commands/skills.js";
 import { registerSourcingFamily } from "../commands/sourcing.js";
 import { registerStatusFamily } from "../commands/status.js";
+import { registerSubscriptionsFamily } from "../commands/subscriptions.js";
 import { registerSupabaseFamily } from "../commands/supabase.js";
 import { registerSupportFamily } from "../commands/support.js";
 import { registerSuppressionsFamily } from "../commands/suppressions.js";
@@ -213,6 +214,7 @@ export function createProgram() {
     registerSequencesFamily(program, handleAsyncAction);
     registerVoiceFamily(program, handleAsyncAction);
     registerSuppressionsFamily(program, handleAsyncAction);
+    registerSubscriptionsFamily(program, handleAsyncAction);
     registerEmailFamily(program, handleAsyncAction);
     registerManagedInboxesFamily(program, handleAsyncAction);
     registerMailboxesFamily(program, handleAsyncAction);

package/dist/command-manifest.js

@@ -4,6 +4,7 @@ import { CLI_EXIT_CODE_TABLE } from "@oxygen/shared/cli-result";
 import { OXYGEN_VERSION } from "@oxygen/shared/version";
 import { inferUserCapabilityRoute } from "@oxygen/shared/user-capability-routing";
 import { serializeCapabilityRoute } from "@oxygen/shared/capability-discovery";
+import { nativeChatHostServed } from "./native-chat-host.js";
 const DEFAULT_COMMAND_SEARCH_LIMIT = 10;
 const MAX_COMMAND_SEARCH_LIMIT = 25;
 const COMMAND_SEARCH_STOP_WORDS = new Set([
@@ -111,6 +112,9 @@ const MUTATING_VERBS = new Set([
 const MUTATING_COMMANDS = new Set([
     // Live DNS checks save observations; --cached explicitly reads saved evidence.
     "domains dns",
+    // Creates or re-checks the Amazon SES identity and records its DKIM and
+    // MAIL FROM state, which can move the sending domain to active.
+    "domains sending verify",
     // Stores one copy-score check run (0 credits, nothing sent); the noun leaf would read as a read.
     "mailboxes deliverability score-copy",
     // Sends the workspace's company documents to Twilio for a human review that
@@ -176,6 +180,9 @@ const MUTATING_COMMANDS = new Set([
 // mode, but a small number of approved operations are explicitly
 // zero-credit. Keep those exceptions exact so discovery never invents spend.
 const ZERO_CREDIT_APPROVAL_COMMANDS = new Set([
+    // Native deliverability tests send approved real email without buying provider credits.
+    "deliverability workspace-test run",
+    "deliverability workspace-test bulk run",
     // --approved hands documents to the carrier's reviewers; no credits, no carrier fee.
     "voice verification submit",
     "domains dns apply",
@@ -268,7 +275,10 @@ const PREVIEW_BY_DEFAULT_COMMANDS = new Set([
     "domains dns apply",
     "mailboxes warmup enable",
     "mailboxes warmup google",
+    "mailboxes standby set",
+    "sequences standby set",
     "deliverability workspace-test run",
+    "deliverability workspace-test bulk run",
     "deliverability placement-test run",
     "deliverability placement-test send",
     "managed-inboxes recover",
@@ -338,7 +348,7 @@ export function searchCommandManifest(manifest, query, requestedLimit = DEFAULT_
     const matches = tokens.length === 0
         ? []
         : manifest.commands
-            .filter((command) => !command.hidden)
+            .filter((command) => !command.hidden && (nativeChatHostServed() || !command.name.startsWith("chat ")))
             .map((command) => ({ command, score: scoreCommand(command, tokens, route) }))
             .filter((entry) => entry.score > 0)
             .sort((a, b) => b.score - a.score || a.command.name.localeCompare(b.command.name));
@@ -346,7 +356,7 @@ export function searchCommandManifest(manifest, query, requestedLimit = DEFAULT_
         query: normalized,
         total_matches: matches.length,
         returned: Math.min(limit, matches.length),
-        route: serializeCapabilityRoute(route),
+        route: serializeCapabilityRoute(route, "cli", { nativeChat: nativeChatHostServed() }),
         commands: matches.slice(0, limit).map(({ command, score }) => ({
             name: command.name,
             group: command.group,

package/dist/commands/budget.js

@@ -8,7 +8,7 @@ export function registerBudgetFamily(program, handleAsyncAction) {
         .command("budget")
         .description("Standing credit caps (org/table daily/monthly hard-blocks) beyond per-run max_credits.")
         .addCommand(new Command("list")
-        .description("Read-only, 0 credits. List standing caps with each policy's current spend and remaining credits, plus plan defaults: the daily spend guard and per-run ceilings of one Agent run, trigger delivery or auto-run batch. Daily/monthly windows start at 00:00 UTC; spend counts reservations minus releases, including open holds. Scoped caps currently measure workspace-wide spend. Every spend default: `oxygen limits show`.")
+        .description("Read-only, 0 credits. List standing caps with each policy's current spend and remaining credits, plus plan defaults: the daily spend guard and per-run ceilings of one Agent run, trigger delivery or auto-run batch. Daily/monthly windows start at 00:00 UTC; spend counts preventive credit exposure: net reservations (including open holds) plus recorded workspace Workflow and BYOK fees, excluding proven duplicate settlement and linked admission transfers. Releases reduce only their own reserve in its UTC window. Fee accrual includes settled and unsettled work; unlinked transfers can count conservatively. Scoped caps currently measure workspace-wide spend. Every spend default: `oxygen limits show`.")
         .option("--scope <scope>", `Filter by scope: ${formatPublicBudgetScopes()}.`)
         .option("--status <status>", "Filter by status. Defaults to all.")
         .option("--json", "Print a JSON envelope.")
@@ -24,7 +24,7 @@ export function registerBudgetFamily(program, handleAsyncAction) {
         });
     }))
         .addCommand(new Command("set")
-        .description("Set, raise, or lower a standing credit cap (idempotent per scope+window). Daily/monthly windows start at 00:00 UTC and count reservations minus releases; inspect current use with `oxygen budget list`.")
+        .description("Set, raise, or lower a standing credit cap (idempotent per scope+window). Daily/monthly windows start at 00:00 UTC and count net reservations plus workspace Workflow and BYOK fee accrual, excluding proven duplicate transfers; inspect current use with `oxygen budget list`.")
         .requiredOption("--scope <scope>", formatPublicBudgetScopes())
         .requiredOption("--window <window>", "per_run, daily, or monthly.")
         .requiredOption("--max-credits <credits>", "Cap in Oxygen credits.")

package/dist/commands/capabilities.js

@@ -1,5 +1,6 @@
 import { OXYGEN_CAPABILITY_ROUTES, getCapabilityRouteMatch, serializeCapabilityRoute, withRecordBrief } from "@oxygen/shared/capability-discovery";
 import { networkMiningHostServed } from "../network-mining-host.js";
+import { nativeChatHostServed } from "../native-chat-host.js";
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { inferUserCapabilityRoute } from "@oxygen/shared/user-capability-routing";
 import { capabilityDiscoveryRecovery } from "@oxygen/shared/user-capability-routing";
@@ -19,7 +20,7 @@ export function registerCapabilitiesFamily(program, handleAsyncAction) {
             const route = inferred ? withRecordBrief(inferred, networkMiningHostServed()) : null;
             return {
                 query,
-                route: serializeCapabilityRoute(route),
+                route: serializeCapabilityRoute(route, "cli", { nativeChat: nativeChatHostServed() }),
                 hint: route
                     ? "Hydrate one exact CLI command with `oxygen commands get <exact-command> --json`, or one MCP tool with `oxygen_capabilities_schema`."
                     : capabilityDiscoveryRecovery(query, "cli"),
@@ -40,7 +41,7 @@ export function registerCapabilitiesFamily(program, handleAsyncAction) {
                     exitCode: 2,
                 });
             }
-            return serializeCapabilityRoute(route);
+            return serializeCapabilityRoute(route, "cli", { nativeChat: nativeChatHostServed() });
         });
     }));
 }

package/dist/commands/columns.js

@@ -360,7 +360,7 @@ const RESEARCH_DEPTHS = new Set(["quick", "standard", "deep"]);
 function quickResearchRowCredits(level) {
     return Math.round((AI_COLUMN_CREDITS[level] + AI_COLUMN_WEB_SEARCH_TYPICAL_CREDITS) * 10) / 10;
 }
-const REASONING_LEVEL_OPTION_HELP = "AI column reasoning level: low, medium, or high (shown in the web UI as Oxygen Fast, Oxygen Balanced, and Oxygen Max). "
+const REASONING_LEVEL_OPTION_HELP = "AI column reasoning level: low, medium (default), or high (shown in the web UI as Oxygen Fast, Oxygen Balanced, and Oxygen Max). "
     + `On a research column it applies only at --research-depth quick (typical row: low about ${quickResearchRowCredits("low")}, `
     + `medium about ${quickResearchRowCredits("medium")}, high about ${quickResearchRowCredits("high")} credits); standard and deep choose their own tier and ignore it.`;
 const RESEARCH_DEPTH_OPTION_HELP = "Research columns: how hard each row searches. quick: one search and one page read (about 2.1 credits/row on the default tier; --reasoning-level applies to quick only). standard: the agent plans a few searches and page reads on Oxygen Fast (about 5.5; the default for new columns). deep: more searches and subpages on Oxygen Balanced (about 10). Standard and deep cost the same whatever --reasoning-level says. Each row reserves a higher maximum; `columns run --dry-run` quotes this column's typical and max.";

package/dist/commands/companies.js

@@ -140,6 +140,8 @@ function readCompaniesEnrichBody(table, options) {
         body.mode = mode;
     if (maxCredits !== undefined)
         body.max_credits = maxCredits;
+    if (options.maxConcurrency !== undefined)
+        body.max_concurrency = Number(options.maxConcurrency);
     if (options.approved)
         body.approved = true;
     if (options.force !== undefined)
@@ -295,6 +297,7 @@ export function registerCompaniesFamily(program, handleAsyncAction) {
         .option("--providers <providers>", "Comma-separated provider pool.")
         .option("--mode <mode>", "dry_run or live. Defaults to live. dry_run returns the same plan as `companies enrich preview` and creates no column; only a live run creates the target columns it fills. To reuse a published workspace Function, inspect `functions list` and attach it with `functions bind` before running the column.")
         .option("--max-credits <n>", "Required credit ceiling for live runs.")
+        .option("--max-concurrency <n>", "Maximum simultaneous rows, 1–1000. Lower to slow provider calls.")
         .option("--approved", "Approve this live paid run after inspecting the preview.")
         .option("--all", "Run on all rows.")
         .option("--limit <n>", "Run on a limited row scope.")

package/dist/commands/domains.js

@@ -3,7 +3,7 @@ import { readRecordString } from "../cli-values.js";
 import { readCount, readJsonFileValue, readRecord, shellQuote, splitCommaList } from "../command-support.js";
 import { requestOxygen } from "../http-client.js";
 import { resolveCliBinaryName } from "../runtime.js";
-import { isRecord, readOption } from "../util.js";
+import { isRecord, readClearableOption, readOption } from "../util.js";
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { sleep } from "@oxygen/shared/timing";
 import { Command } from "commander";
@@ -149,9 +149,14 @@ function readDnsDkimOption(value) {
     return records;
 }
 function dnsPlanBody(options) {
+    const sendingDomain = readOption(options.sendingDomain);
+    // Sending-domain mode plans exactly that sending domain's SES records; the
+    // mailbox-provider flags do not apply, so none of them is sent.
+    if (sendingDomain)
+        return { sending_domain: sendingDomain };
     const provider = readOption(options.provider);
     if (!provider) {
-        throw new Error("--provider <google|microsoft> is required so the correct SPF/MX/DKIM records can be planned.");
+        throw new Error("--provider <google|microsoft> is required so the correct SPF/MX/DKIM records can be planned (or pass --sending-domain).");
     }
     return {
         provider,
@@ -167,6 +172,10 @@ function dnsPlanBody(options) {
 async function runDomainsDnsPlan(domain, options) {
     const data = await requestOxygen(`/api/cli/domains/${encodeURIComponent(domain)}/dns/plan`, { method: "POST", body: dnsPlanBody(options) });
     const planHash = readRecordString(data, "plan_hash");
+    const sendingDomain = readOption(options.sendingDomain);
+    if (planHash && sendingDomain) {
+        return { ...data, rerun_command: [resolveCliBinaryName(), "domains dns apply", shellQuote(domain), "--sending-domain", shellQuote(sendingDomain), "--approved --plan", shellQuote(planHash)].join(" ") };
+    }
     const provider = readOption(options.provider);
     return planHash && provider
         ? { ...data, rerun_command: [resolveCliBinaryName(), "domains dns apply", shellQuote(domain), "--provider", shellQuote(provider), "--approved --plan", shellQuote(planHash),
@@ -286,6 +295,111 @@ async function waitForDomainRegistration(domain) {
         await sleep(Math.min(delayMs, remainingMs));
     }
 }
+function readDailyCeiling(value) {
+    const raw = readOption(value);
+    if (raw === null)
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new OxygenError("invalid_request", "--daily-ceiling must be a whole number of emails per day.", { exitCode: 2 });
+    }
+    return parsed;
+}
+// A comma list; an explicit "" clears the list ([]), absence leaves it alone.
+function readFromAddressesOption(value) {
+    if (value === undefined)
+        return undefined;
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function sendingDomainSettingsBody(options) {
+    const allowedFromAddresses = readFromAddressesOption(options.allowedFromAddresses);
+    const replyToMailboxId = readClearableOption(options.replyToMailboxId);
+    const dailyCeiling = readDailyCeiling(options.dailyCeiling);
+    return {
+        ...(allowedFromAddresses !== undefined ? { allowed_from_addresses: allowedFromAddresses } : {}),
+        ...(replyToMailboxId !== undefined ? { reply_to_mailbox_id: replyToMailboxId } : {}),
+        ...(dailyCeiling !== undefined ? { daily_ceiling: dailyCeiling } : {}),
+    };
+}
+function runSendingDomainAdd(identity, options) {
+    const emailDomain = readOption(options.emailDomain);
+    const mailFromDomain = readOption(options.mailFromDomain);
+    return requestOxygen("/api/cli/sequencer/sending-domains", {
+        method: "POST",
+        body: {
+            identity,
+            ...(emailDomain ? { email_domain: emailDomain } : {}),
+            ...(mailFromDomain ? { mail_from_domain: mailFromDomain } : {}),
+            ...sendingDomainSettingsBody(options),
+        },
+    });
+}
+function runSendingDomainUpdate(id, options) {
+    const body = sendingDomainSettingsBody(options);
+    if (Object.keys(body).length === 0) {
+        throw new OxygenError("invalid_request", "Pass --daily-ceiling, --allowed-from-addresses or --reply-to-mailbox-id.", { exitCode: 2 });
+    }
+    return requestOxygen(`/api/cli/sequencer/sending-domains/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body,
+    });
+}
+function runSendingDomainPause(id, paused, reason) {
+    const pauseReason = readOption(reason);
+    return requestOxygen(`/api/cli/sequencer/sending-domains/${encodeURIComponent(id)}/pause`, {
+        method: "POST",
+        body: { paused, ...(paused && pauseReason ? { reason: pauseReason } : {}) },
+    });
+}
+function sendingDomainsCommand(handleAsyncAction) {
+    const settingsFlags = (command) => command
+        .option("--allowed-from-addresses <list>", "Comma-separated From addresses on the sending domain; \"\" clears.")
+        .option("--reply-to-mailbox-id <id-or-address>", "Mailbox replies go to; \"\" clears.")
+        .option("--daily-ceiling <n>", "Most bulk emails per day from this domain (default 1000).")
+        .option("--json", "Print a JSON envelope.");
+    return new Command("sending")
+        .description("Sending domains: Sequencer accounts that send bulk email (newsletters, onboarding) through Amazon SES from a verified domain, not a mailbox. Add one on a domain from `domains list`, publish its DNS with `domains dns plan <zone> --sending-domain <domain>`, then verify. 0 credits.")
+        .addCommand(new Command("list")
+        .description("List sending domains with status, DKIM and MAIL FROM verification, daily ceiling and the DNS records each needs. No provider calls.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("domains sending list", options, () => requestOxygen("/api/cli/sequencer/sending-domains"));
+    }))
+        .addCommand(settingsFlags(new Command("add")
+        .description("Add a sending domain (a domain or subdomain such as news.acme.com) and, where available, create its Amazon SES identity so its DKIM records are known. Returns dns_records and the next step. 0 credits.")
+        .argument("<domain>", "Sending domain, such as news.acme.com.")
+        .option("--email-domain <id-or-domain>", "The domain from `domains list` it belongs to (default: the longest one containing it).")
+        .option("--mail-from-domain <domain>", "Custom MAIL FROM subdomain (default mail.<domain>).")).action(async (identity, options) => {
+        await handleAsyncAction("domains sending add", options, () => runSendingDomainAdd(identity, options));
+    }))
+        .addCommand(new Command("verify")
+        .description("Check the sending domain's DKIM and MAIL FROM with Amazon SES and record the result; both verified makes a pending domain active. 0 credits.")
+        .argument("<domain>", "Sending domain id or name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("domains sending verify", options, () => requestOxygen(`/api/cli/sequencer/sending-domains/${encodeURIComponent(id)}/verify`, { method: "POST" }));
+    }))
+        .addCommand(new Command("pause")
+        .description("Pause a sending domain: it sends nothing until resumed; queued bulk sends wait.")
+        .argument("<domain>", "Sending domain id or name.")
+        .option("--reason <text>", "Why it is paused, shown on the account.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("domains sending pause", options, () => runSendingDomainPause(id, true, options.reason));
+    }))
+        .addCommand(new Command("resume")
+        .description("Resume a paused sending domain. Refused until its DKIM and MAIL FROM are verified.")
+        .argument("<domain>", "Sending domain id or name.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (id, options) => {
+        await handleAsyncAction("domains sending resume", options, () => runSendingDomainPause(id, false, undefined));
+    }))
+        .addCommand(settingsFlags(new Command("update")
+        .description("Change a sending domain's daily ceiling, allowed From addresses or reply-to mailbox.")
+        .argument("<domain>", "Sending domain id or name.")).action(async (id, options) => {
+        await handleAsyncAction("domains sending update", options, () => runSendingDomainUpdate(id, options));
+    }));
+}
 export function registerDomainsFamily(program, handleAsyncAction) {
     program.addCommand(new Command("domains")
         .description("Cold-email domains: sync zones from your own Cloudflare account (BYOK), inspect age/warmup/DNS health, check availability and pricing, buy domains, and archive or delete domains with their inboxes (OXYGEN-bought domains included). Your own Cloudflare account bills purchases to its payment method; domains registered by OXYGEN cost credits at the vendor price. Preview `domains buy` before approval.")
@@ -464,9 +578,10 @@ export function registerDomainsFamily(program, handleAsyncAction) {
         await handleAsyncAction("domains dns", options, () => requestOxygen(`/api/cli/domains/${encodeURIComponent(domain)}/dns${suffix}`));
     })
         .addCommand(new Command("plan")
-        .description("Preview the cold-email DNS records a domain should hold for its mailbox provider (SPF, per-provider DKIM, DMARC, MX, optional tracking) as a create/update/keep/conflict diff plus a plan_hash. FREE — nothing is written. Own Cloudflare zones only; DNS editing for Oxygen-bought domains is unavailable. Keep their nameservers and contact support.")
+        .description("Preview the cold-email DNS records a domain should hold for its mailbox provider (SPF, per-provider DKIM, DMARC, MX, optional tracking), or with --sending-domain that sending domain's SES records, as a create/update/keep/conflict diff plus a plan_hash. FREE — nothing is written. Own Cloudflare zones only; DNS editing for Oxygen-bought domains is unavailable. Keep their nameservers and contact support.")
         .argument("<domain>", "Domain name, such as acme.com.")
-        .requiredOption("--provider <provider>", "Mailbox provider: google or microsoft (determines SPF/MX/DKIM).")
+        .option("--provider <provider>", "Mailbox provider: google or microsoft (determines SPF/MX/DKIM). Required unless --sending-domain.")
+        .option("--sending-domain <id-or-domain>", "Plan exactly this sending domain's SES records (DKIM CNAMEs, MAIL FROM MX and SPF) instead; mailbox flags are ignored.")
         .option("--dmarc-policy <policy>", "DMARC policy: none (default), quarantine, or reject.")
         .option("--dmarc-rua <mailbox>", "DMARC aggregate-report mailbox (rua=mailto:...).")
         .option("--tracking-host <host>", "Open/click tracking CNAME host (only planned when tracking is configured).")
@@ -479,7 +594,8 @@ export function registerDomainsFamily(program, handleAsyncAction) {
         .addCommand(new Command("apply")
         .description("Write the planned cold-email DNS records into your own Cloudflare zone. Requires a fresh plan_hash from `dns plan`. No Oxygen credits. Without --approved, re-previews the plan. DNS editing for Oxygen-bought domains is unavailable; keep their nameservers and contact support.")
         .argument("<domain>", "Domain name, such as acme.com.")
-        .requiredOption("--provider <provider>", "Mailbox provider: google or microsoft (must match the plan).")
+        .option("--provider <provider>", "Mailbox provider: google or microsoft (must match the plan). Required unless --sending-domain.")
+        .option("--sending-domain <id-or-domain>", "Write this sending domain's SES records (must match the plan).")
         .option("--approved", "Write the records. Without this flag, returns a plan preview only.")
         .option("--plan <hash>", "plan_hash from a fresh `dns plan` (required with --approved).")
         .option("--dmarc-policy <policy>", "DMARC policy: none (default), quarantine, or reject.")
@@ -512,6 +628,7 @@ export function registerDomainsFamily(program, handleAsyncAction) {
         .action(async (domain, options) => {
         await handleAsyncAction("domains tracking status", options, () => requestOxygen(`/api/cli/domains/${encodeURIComponent(domain)}/tracking`));
     })))
+        .addCommand(sendingDomainsCommand(handleAsyncAction))
         .addCommand(new Command("add")
         .description("BYOK CLOUDFLARE: onboard a domain registered elsewhere by creating a zone in your connected Cloudflare account. For managed domain + inbox provisioning use `managed-inboxes subscribe`.")
         .argument("<domain>", "Apex domain to add, such as acme.com.")

package/dist/commands/feedback.js

@@ -69,7 +69,7 @@ function buildFeedbackBody(options) {
 export function registerFeedbackFamily(program, handleAsyncAction) {
     program
         .command("feedback")
-        .description("Send feedback or a bug report to the OXYGEN team. This is the same immediate, zero-credit canonical Plain conversation write as `support chat`; transcripts are never attached unless explicitly requested.")
+        .description("Send feedback or a bug report to the OXYGEN team. This is an immediate, zero-credit write: a native workspace conversation on enabled dev, otherwise a Plain conversation, including production; transcripts are never attached unless explicitly requested.")
         .option("-m, --message <message>", "Your feedback or bug report.")
         .option("--severity <severity>", "low | normal | high. Defaults to normal.")
         .option("--category <category>", "Optional category label. Defaults to 'feedback'.")

package/dist/commands/feeds.js

@@ -49,22 +49,27 @@ function readFeedBindBody(table, options) {
     const maxCreditsPerCycle = readPositiveNumber(options.maxCredits);
     const maxRowsPerCycle = readPositiveInt(options.maxRows);
     const filters = options.filtersJson ? parseJsonObject(readFileIfPresent(options.filtersJson)) : null;
+    // An explicitly empty value is invalid JSON, not the legacy mode or cwd.
+    if (options.routeJson === "")
+        parseJsonObject(options.routeJson);
+    const route = options.routeJson !== undefined
+        ? parseJsonObject(readFileIfPresent(options.routeJson)) : {
+        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) } : {}),
+        ...(options.rowMappingJson ? { row_mapping: parseJsonObject(readFileIfPresent(options.rowMappingJson)) } : {}),
+        ...(readOption(options.cursorPath) ? { cursor_path: readOption(options.cursorPath) } : {}),
+        ...(readOption(options.cursorRequestKey) ? { cursor_request_key: readOption(options.cursorRequestKey) } : {}),
+        ...(maxPages !== undefined ? { max_pages: maxPages } : {}),
+        ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+    };
     return {
         table,
         transport: "pull",
         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) } : {}),
-            ...(options.rowMappingJson ? { row_mapping: parseJsonObject(readFileIfPresent(options.rowMappingJson)) } : {}),
-            ...(readOption(options.cursorPath) ? { cursor_path: readOption(options.cursorPath) } : {}),
-            ...(readOption(options.cursorRequestKey) ? { cursor_request_key: readOption(options.cursorRequestKey) } : {}),
-            ...(maxPages !== undefined ? { max_pages: maxPages } : {}),
-            ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
-        },
+        route,
         sync: {
             ...(every ? { every } : {}),
             ...(maxCreditsPerCycle !== undefined ? { max_credits_per_cycle: maxCreditsPerCycle } : {}),
@@ -88,6 +93,7 @@ const FEED_BIND_PULL_ONLY_FLAGS = [
     ["toolId", "--tool-id"],
     ["toolIds", "--tool-ids"],
     ["requestJson", "--request-json"],
+    ["routeJson", "--route-json"],
     ["rowsPath", "--rows-path"],
     ["rowMappingJson", "--row-mapping-json"],
     ["cursorPath", "--cursor-path"],
@@ -154,11 +160,19 @@ function assertPullFeedBindArguments(table, options, command) {
             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>"],
-    ];
+    if (options.routeJson !== undefined) {
+        for (const [key, flag] of [
+            ["toolId", "--tool-id"], ["requestJson", "--request-json"], ["toolIds", "--tool-ids"],
+            ["rowsPath", "--rows-path"], ["rowMappingJson", "--row-mapping-json"],
+            ["cursorPath", "--cursor-path"], ["cursorRequestKey", "--cursor-request-key"],
+            ["maxPages", "--max-pages"], ["upsertKey", "--upsert-key"],
+        ])
+            if (options[key] !== undefined)
+                command.error("error: --route-json cannot be combined with " + flag);
+    }
+    const required = options.routeJson !== undefined
+        ? [["kind", "--kind <kind>"]]
+        : [["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" });
@@ -352,6 +366,7 @@ export function registerFeedsFamily(program, handleAsyncAction) {
         .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("--route-json <json-or-file>", "Complete pull route including explicit fallback lanes, inline or a JSON file; replaces the tool/request/mapping flags. When using multiple lanes, omit the cadence.")
         .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.")
@@ -390,6 +405,8 @@ Examples:
 `)
         .action((table, options, command) => {
         if (options.kind === LEAD_POST_WATCH_KIND) {
+            if (options.routeJson !== undefined)
+                command.error("error: --route-json does not apply to the fixed lead_post_watch source");
             return handleAsyncAction("feeds bind", options, () => requestOxygen("/api/cli/tables/feeds", {
                 method: "POST",
                 body: readLeadPostWatchBindBody(table, options),

package/dist/commands/mailboxes.js

@@ -1,13 +1,14 @@
 import { emitCliFailure, emitSuccess, writeBillingNotices } from "../cli-output.js";
 import { readNonNegativeInt, readPositiveInt } from "../cli-values.js";
-import { readCsvOption, readNonNegativeNumber, splitCommaList } from "../command-support.js";
+import { readCsvOption, readNonNegativeNumber, splitCommaList, handleReadActionWithLens } from "../command-support.js";
 import { requestOxygen } from "../http-client.js";
 import { readOption } from "../util.js";
 import { withDeliverabilityEvidenceCommands } from "../deliverability-evidence-commands.js";
 import { OxygenError } from "@oxygen/shared/cli-result";
 import { inferRowsFileFormat, 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";
-import { Command } from "commander";
+import { Command, Option } from "commander";
+import { formatMailboxFleetHealth, formatMailboxRoster } from "../mailbox-fleet-output.js";
 import { readFileSync } from "node:fs";
 import { basename, resolve } from "node:path";
 /**
@@ -405,7 +406,7 @@ async function readMailboxImportFile(path) {
 }
 export function registerMailboxesFamily(program, handleAsyncAction) {
     program.addCommand(new Command("mailboxes")
-        .description("Connect customer-owned Gmail/Microsoft 365 inboxes with `oxygen mailboxes connect-oauth --vendor composio` for mail history in Unibox and business activity in CRM; read and control progress with `oxygen mailboxes sync`. Also operate the native email sending pool: register/refresh Google/Microsoft mailboxes (including Microsoft SMTP transport and secure local credential-file transfer), pause, disable or delete inboxes, connect OXYGEN deliverability monitoring, and inspect/control OXYGEN Warm-up. Fresh managed InboxKit Google/Microsoft/Azure orders activate exact-scope warm-up automatically after provisioning under their approved default-on add-on. Google reuses the managed credential just in time; Microsoft/Azure uses native export. Standalone warm-up plans and credit caps are for BYOK/imported mailboxes, managed opt-outs, or later separate enrollment. OXYGEN Warm-up never owns campaign dispatch. Every inbox here always belongs to a sender profile (the person it sends as) — list, create, and attach those with `oxygen senders profiles`. Safe import preflight: run `oxygen mailboxes compatibility --catalog-only --json`, then `oxygen mailboxes import --file <path> --validate-only --json` (add the credential source flags shown by import help when the file contains credentials).")
+        .description("Connect customer-owned Gmail/Microsoft 365 inboxes with `oxygen mailboxes connect-oauth --vendor composio` for mail history in Unibox and business activity in CRM; read and control progress with `oxygen mailboxes sync`. Also operate the native email sending pool: register/refresh Google/Microsoft mailboxes (including Microsoft SMTP transport and secure local credential-file transfer), pause, disable or delete inboxes, connect OXYGEN deliverability monitoring, and inspect/control OXYGEN Warm-up. Fresh managed InboxKit Google/Microsoft/Azure orders activate exact-scope warm-up automatically after provisioning under their approved default-on add-on. Google reuses the managed credential just in time; Microsoft/Azure uses native export. Standalone warm-up plans and credit caps are for BYOK/imported mailboxes, managed opt-outs, or later separate enrollment. OXYGEN Warm-up never owns campaign dispatch. New inboxes receive a sender profile (the person they send as) unless explicitly detached — list, create, and attach those with `oxygen senders profiles`. Safe import preflight: run `oxygen mailboxes compatibility --catalog-only --json`, then `oxygen mailboxes import --file <path> --validate-only --json` (add the credential source flags shown by import help when the file contains credentials).")
         .addCommand(new Command("google-workspace")
         .description("Authorize a Workspace administrator for Gmail audit/usage, domains, users, groups, verification and Postmaster data. Separate from individual mailbox consent and paid warm-up/OXYGEN deliverability enrollment.")
         .addCommand(new Command("connect")
@@ -433,7 +434,8 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
             return requestOxygen(`/api/cli/mailboxes/google-workspace/status?${query.toString()}`);
         });
     }))
-        .addCommand(new Command("disconnect <connection-id>")
+        .addCommand(new Command("disconnect")
+        .argument("<connection-id>")
         .description("Remove OXYGEN's stored administrator credential for this connection. Mailbox grants remain separate.")
         .option("--approved", "Confirm removing this administrator connection.")
         .option("--json", "Print JSON.")
@@ -447,9 +449,10 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
         .option("--status <status>", "Filter by status: active, paused, disabled, or provisioning (ordered, still being set up).")
         .option("--tag <tags>", "Comma-separated workspace tags — matches mailboxes carrying ANY of these tags (see `oxygen tags list`).")
         .option("--warmup <states>", "Show only mailboxes whose warm-up is in one of these states (comma-separated): warming, active, paused, error, disabled, pending, not_enrolled, unknown.")
-        .option("--next-action <codes>", "Show only mailboxes whose warm-up needs one of these next steps (comma-separated): none, resume_warmup, reconnect_warmup, enable_warmup, connect_oauth, fix_dns, wait, contact_support.")
+        .option("--next-action <codes>", "Show only mailboxes whose warm-up needs one of these next steps (comma-separated): none, resume_warmup, reconnect_warmup, reactivate_warmup, enable_warmup, connect_oauth, fix_dns, wait, contact_support.")
         .option("--stalled", "Show only mailboxes enrolled in warm-up with zero recorded sends (warmupTruth.dispatch.sent null or 0) — the seats you are paying for that are silent. In practice these are the `pending` truth state; an `error` seat has usually sent some mail before it stopped, so it is not stalled.")
-        .option("--json", "Print a JSON envelope. The full payload carries per-mailbox daily warm-up metrics, so a large fleet is megabytes — narrow it with --stalled / --warmup / --next-action, or read the default human view, which already aggregates the pool.")
+        .option("--json", "Print a JSON envelope. Use --view summary for the complete compact roster; the default full view carries per-inbox evidence and repair commands.")
+        .addOption(new Option("--view <view>", "Full per-inbox evidence (default), or compact complete summary roster.").choices(["summary", "full"]))
         .action(async (options) => {
         const params = new URLSearchParams();
         const status = readOption(options.status);
@@ -468,6 +471,8 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
         // server never has to decide what an unasked-for `stalled=false` meant.
         if (options.stalled)
             params.set("stalled", "true");
+        if (options.view)
+            params.set("view", options.view);
         const suffix = params.toString();
         // What this CLI asked for, kept as flags in query order: a server too
         // old to echo `filters` back still must not let a match count read as
@@ -498,7 +503,11 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
             emitSuccess("mailboxes list", result, options);
             return;
         }
-        writeMailboxPoolOverview(result, { filtered: suffix.length > 0, filterFlags });
+        if (options.view === "summary") {
+            process.stdout.write(formatMailboxRoster(result));
+            return;
+        }
+        writeMailboxPoolOverview(result, { filtered: filterFlags.length > 0, filterFlags });
     }))
         .addCommand(new Command("get")
         .description("Get one sending mailbox's configuration/readiness detail (provider, status, daily cap, warmup state, auth mode, and source — managed vs bring-your-own) plus a one-row pool summary. effective_cap comes first: today's campaign limit (effective_daily_cap), the ramp-up mode and its ramp_schedule. This is not sent/replied/bounced performance; use `oxygen sequences analytics` for native Sequence attribution by mailbox/domain. An ineligible native-send transport includes transport_reason + transport_hint; it does not by itself block OXYGEN Warm-up or OXYGEN deliverability monitoring. <mailbox> accepts a mailbox id or email address.")
@@ -543,10 +552,11 @@ export function registerMailboxesFamily(program, handleAsyncAction) {
         });
     }))
         .addCommand(new Command("health")
-        .description("Fleet email-health: the sending pool rolled up by external deliverability reputation (healthy/degraded/critical/unknown), per-mailbox scores, connected health providers, and DIRECTIONAL recommendations — plus OXYGEN's OWN evidence for the last 7 days, which needs no provider connected: the bounce notifications each mailbox received classified as provider rejection / dead address / mailbox full / delay (a Gmail reputation block shows up as provider_rejected), distinct recipients with a hard bounce in the window (legacy facts retain their first observation time), sequence sends OXYGEN logged (source=sequence only), warm-up day, health score and stop cause, each mailbox's configured daily cap, and the same rollup per sending domain ranked worst-first. Notifications whose body was never stored count as signals.dsn7d.unclassified, which means OXYGEN could not look — not that nothing was wrong. Read health_coverage to see how many mailboxes an external provider has actually scored. Start from the fleet read instead of scanning the mailbox array: warmup.byCause (why warm-up stopped, counted once for the whole pool). Every count is scoped, and the scope is stamped into the payload as signals.window (7d) and signals.sendSource (sequence sends only), on the fleet object and on every mailbox: a 0 means nothing was recorded in that window for that send source, NOT that the fleet is un-blocklisted everywhere. Pure read — 0 credits; never pauses a mailbox or changes a cap.")
+        .description("Fleet email-health: the sending pool rolled up by external deliverability reputation (healthy/degraded/critical/unknown), per-mailbox scores, connected health providers, and DIRECTIONAL recommendations — plus OXYGEN's OWN evidence for the last 7 days, which needs no provider connected: the bounce notifications each mailbox received classified as provider rejection / dead address / mailbox full / delay (a Google receiving-server policy rejection shows up as provider_rejected), distinct recipients with a hard bounce in the window (legacy facts retain their first observation time), sequence sends OXYGEN logged (source=sequence only), warm-up day, health score and stop cause, each mailbox's configured daily cap, and the same rollup per sending domain ranked worst-first. Notifications whose body was never stored count as signals.dsn7d.unclassified, which means OXYGEN could not look — not that nothing was wrong. Read health_coverage to see how many mailboxes an external provider has actually scored. Start from the fleet read instead of scanning the mailbox array: warmup.byCause (why warm-up stopped, counted once for the whole pool). Per-mailbox warmup.state and fleet warmup.byState are stored rail telemetry; use `oxygen mailboxes list --json` warmupTruth for enrollment state and next actions. The rolling window is signals.window (7d). Delivery notifications include all send sources, including warm-up and manual mail; signals.sendSource=sequence restricts only coldSends7d. Identified warm-up rejections are reported separately, and other notifications have no verified send-source attribution. Rejections alone do not establish that prospect mail was rejected or that a whole domain is blocked. A zero means no such evidence was recorded in the stated window, not that the fleet is un-blocklisted everywhere. Pure read — 0 credits; never pauses a mailbox or changes a cap.")
+        .addOption(new Option("--view <view>", "Summary: complete compact roster (default); fleet: domain, DSN and warm-up totals without rows; full: all inbox evidence.").choices(["summary", "fleet", "full"]))
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
-        await handleAsyncAction("mailboxes health", options, () => requestOxygen("/api/cli/mailboxes/health"));
+        await handleReadActionWithLens("mailboxes health", options, () => requestOxygen(`/api/cli/mailboxes/health?view=${encodeURIComponent(options.view ?? "summary")}`), formatMailboxFleetHealth);
     }))
         .addCommand(new Command("compatibility")
         .description("Read-only compatibility report per mailbox — select with --mailboxes <address,…> (omit for the whole pool; filter here, not in a script): generic origin class, real infrastructure tier (including InboxKit Azure), OXYGEN native-send connection quality, OXYGEN Warm-up path, OXYGEN deliverability monitoring path, and exact next actions. Read automatic_repair for native send and warmup_automatic_repair for an existing warm-up seat: mode=automatic means OXYGEN owns the next bounded retry. Native send distinguishes destination-bound OAuth, provider-managed API transport, admin delegation, and authorization_required. Use --catalog-only for the compact workspace-independent import contract. JSON data.compatibility contains checked rows; data.import_methods and data.import_fields describe accepted transfer inputs; data.provider_matrix is the current public product matrix; data.non_transferable_auth names credentials that must be reconnected; data.summary rolls up states; data.web_url opens the pool. Downstream states distinguish credential_required, consent_required, and vendor_blocked. Never decrypts a credential or calls a downstream provider.")

package/dist/commands/publishing.js

@@ -841,7 +841,7 @@ export function registerPublishingFamily(program, handleAsyncAction) {
         }));
     }))
         .addCommand(new Command("approve")
-        .description("Approve a draft or scheduled post; drafts become scheduled for their saved publish time. Costs 0 credits. LinkedIn checks person handles and page IDs before arming. Current resolved previews with handle mismatches fail before lookups. Company handles are rechecked through the selected sender and server identity cache; free provider reads may be needed even with stored previews. Fix tags with `publishing posts update` and matching mention_previews. queued_at records first arming; publish_at controls publication. Program drafts require UGC approval.")
+        .description("Approve a draft or scheduled post; drafts become scheduled for their saved publish time. Costs 0 credits. Owner-only profile approval is configured with senders limits set --publishing-approval-mode owner. LinkedIn checks person handles and page IDs before arming. Current resolved previews with handle mismatches fail before lookups. Company handles are rechecked through the selected sender and server identity cache; free provider reads may be needed even with stored previews. Fix tags with `publishing posts update` and matching mention_previews. queued_at records first arming; publish_at controls publication. Program drafts require UGC approval.")
         .argument("<post_id>", "Draft or scheduled post id.")
         .option("--json", "Print a JSON envelope.")
         .action(async (postId, options) => {

package/dist/commands/senders.js

@@ -220,7 +220,7 @@ export function registerSendersFamily(program, handleAsyncAction) {
         });
     })))
         .addCommand(new Command("profiles")
-        .description("Sender profiles: group a person's LinkedIn + WhatsApp senders and email inboxes into one sending identity — one name, one first/last name, one photo. A sequence can then send every channel from the same persona, and `oxygen managed-inboxes subscribe/add-inboxes --sender <id>` orders new mailboxes under that identity instead of making you retype it per mailbox. Every email inbox always belongs to one of these profiles, so attaching moves an inbox and detaching one is refused. Manage: list, get, create, update, set-photo, attach/detach accounts, delete.")
+        .description("Sender profiles: group a person's LinkedIn + WhatsApp senders and email inboxes into one sending identity — one name, one first/last name, one photo. A sequence can then send every channel from the same persona, and `oxygen managed-inboxes subscribe/add-inboxes --sender <id>` orders new mailboxes under that identity instead of making you retype it per mailbox. New inboxes receive a profile by default. Attaching moves an inbox; explicit detachment leaves it unassigned. Manage: list, get, create, update, set-photo, attach/detach accounts, delete.")
         .addCommand(new Command("list")
         .description("List sender profiles with their per-channel account counts (LinkedIn / WhatsApp / inboxes).")
         .option("--status <status>", "Filter by status: active, paused, or archived.")
@@ -371,7 +371,7 @@ export function registerSendersFamily(program, handleAsyncAction) {
         }));
     }))
         .addCommand(new Command("detach")
-        .description("Detach LinkedIn/WhatsApp senders from a profile, returning them to the unassigned pool. --mailboxes is refused: an email inbox always belongs to a sender, so there is no unassigned pool for it — move it with `senders profiles attach <other-profile> --mailboxes <id>`, which reassigns it.")
+        .description("Detach LinkedIn/WhatsApp senders or email inboxes from this profile. Explicitly detached inboxes remain unassigned; attaching to another profile moves them.")
         .argument("<id>", "Sender profile id.")
         .option("--senders <ids>", "Comma-separated sender account ids to detach.")
         .option("--mailboxes <ids>", "Comma-separated email mailbox ids to detach.")