@oxygen-agent/cli 1.1010.905 → 1.1010.952

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.1010.905
+Version: 1.1010.952

package/dist/contract-flags.d.ts

@@ -0,0 +1,42 @@
+import { type Command } from "commander";
+import { type ContractObject } from "@oxygen/shared/contracts/schema";
+export type ContractFlagOverlayEntry = {
+    /** Replaces the derived flag name (no leading dashes). */
+    flag?: string;
+    help?: string;
+    /** Value placeholder, e.g. `<n>`; defaults to `<value>` (`<json>` for a JSON flag). */
+    valueName?: string;
+    /** Further accepted spellings, hidden from help. */
+    aliases?: readonly string[];
+    /** Boolean: help for the `--no-<flag>` form. */
+    negateHelp?: string;
+    /**
+     * Boolean as two flags, e.g. `--warmup-restart` (true) / `--warmup-disable`
+     * (false). When both are given, `off` wins.
+     */
+    pair?: {
+        on: string;
+        onHelp: string;
+        off: string;
+        offHelp: string;
+    };
+    /** Replaces the typed parse; the returned value is sent as is (the route validates it). */
+    parse?: (raw: string) => unknown;
+    /** Object: its fields become flags without the object's prefix. */
+    flatten?: boolean;
+    /** Nullable: do not generate the `--clear-<flag>` form. */
+    noClear?: boolean;
+    /** Leave the field off this command entirely. */
+    omit?: boolean;
+};
+/** Keyed by dotted contract path, e.g. `working_hours.timezone`. */
+export type ContractFlagOverlay = Readonly<Record<string, ContractFlagOverlayEntry>>;
+/** Registers the contract's flags on `command`, in contract order. */
+export declare function addContractFlags(command: Command, contract: ContractObject, overlay?: ContractFlagOverlay): Command;
+/**
+ * The request body the parsed flags describe: only the fields given, nested as
+ * the contract nests them. An object none of whose flags was given is absent.
+ */
+export declare function readContractFlags(options: Record<string, unknown>, contract: ContractObject, overlay?: ContractFlagOverlay): Record<string, unknown>;
+/** Every long flag `addContractFlags` registers, in order (for tests and docs). */
+export declare function contractFlagNames(contract: ContractObject, overlay?: ContractFlagOverlay): string[];

package/dist/contract-flags.js

@@ -0,0 +1,220 @@
+// The CLI half of a shared resource contract (@oxygen/shared/contracts/schema).
+// A command's flags and the request body they build are generated from the same
+// contract that generates the MCP input schema and validates the route, so a
+// settable field cannot exist on one surface and not the other.
+//
+// Derivation (the overlay only renames, re-words, aliases or hides):
+//   scalar            --<kebab-name> <value>       numbers parsed and range-checked
+//   enum              --<kebab-name> <value>       membership checked
+//   boolean           --<x> / --no-<x>             tri-state: absent = not sent
+//   array of scalars  --<kebab-name> <a,b,c>
+//   object, <= 6 scalar fields   --<obj>-<field> per field
+//   larger object     --<obj>-json <json>
+//   nullable          also --clear-<x>, which sends null
+// Every value is checked inside the action (never in a Commander parser), so a
+// bad value comes back as the JSON error envelope, not a raw stack trace.
+import { Option } from "commander";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { unwrapNullable } from "@oxygen/shared/contracts/schema";
+const MAX_SPLAT_FIELDS = 6;
+function kebab(name) {
+    return name.replace(/_/g, "-");
+}
+function attribute(flag) {
+    return flag.replace(/-([a-z0-9])/g, (_match, char) => char.toUpperCase());
+}
+function isObject(property) {
+    return "type" in property && property.type === "object" && property.properties !== undefined;
+}
+function contractFlagSpecs(properties, overlay, parentPath = [], parentFlag = "") {
+    const specs = [];
+    for (const [name, raw] of Object.entries(properties)) {
+        const path = [...parentPath, name];
+        const entry = overlay[path.join(".")] ?? {};
+        if (entry.omit)
+            continue;
+        const { property, nullable } = unwrapNullable(raw);
+        const flag = entry.flag ?? `${parentFlag}${kebab(name)}`;
+        if (isObject(property)) {
+            const fields = Object.values(property.properties ?? {});
+            const splat = entry.flatten || (fields.length <= MAX_SPLAT_FIELDS && !fields.some((field) => isObject(unwrapNullable(field).property)));
+            if (splat)
+                specs.push(...contractFlagSpecs(property.properties ?? {}, overlay, path, entry.flatten ? "" : `${flag}-`));
+            else
+                specs.push({ kind: "json", path, flag: `${flag}-json`, entry });
+        }
+        else if ("type" in property && property.type === "boolean") {
+            specs.push(entry.pair ? { kind: "pair", path, on: entry.pair.on, off: entry.pair.off, entry } : { kind: "boolean", path, flag, entry });
+        }
+        else {
+            specs.push({ kind: "value", path, flag, property, entry });
+        }
+        if (nullable && !entry.noClear)
+            specs.push({ kind: "clear", path, flag: `clear-${flag}`, target: flag });
+    }
+    return specs;
+}
+function helpFor(spec, property) {
+    if (spec.entry.help !== undefined)
+        return spec.entry.help;
+    const description = property && "description" in property ? property.description ?? "" : "";
+    const values = property && "enum" in property && property.enum ? ` One of: ${property.enum.join(", ")}.` : "";
+    return `${description}${values}`.trim();
+}
+function propertyAt(contract, path) {
+    let current = contract;
+    for (const key of path) {
+        const unwrapped = current ? unwrapNullable(current).property : undefined;
+        current = unwrapped && isObject(unwrapped) ? unwrapped.properties?.[key] : undefined;
+    }
+    return current ? unwrapNullable(current).property : undefined;
+}
+/** Registers the contract's flags on `command`, in contract order. */
+export function addContractFlags(command, contract, overlay = {}) {
+    for (const spec of contractFlagSpecs(contract.properties, overlay)) {
+        const property = "path" in spec ? propertyAt(contract, spec.path) : undefined;
+        if (spec.kind === "pair") {
+            command.addOption(new Option(`--${spec.on}`, spec.entry.pair?.onHelp));
+            command.addOption(new Option(`--${spec.off}`, spec.entry.pair?.offHelp));
+            continue;
+        }
+        if (spec.kind === "clear") {
+            command.addOption(new Option(`--${spec.flag}`, `Clear it (sends null). Not with --${spec.target}.`));
+            continue;
+        }
+        if (spec.kind === "boolean") {
+            command.addOption(new Option(`--${spec.flag}`, helpFor(spec, property)));
+            command.addOption(new Option(`--no-${spec.flag}`, spec.entry.negateHelp ?? `Sends ${spec.path.join(".")}: false.`));
+            continue;
+        }
+        const valueName = spec.entry.valueName ?? (spec.kind === "json" ? "<json>" : "<value>");
+        command.addOption(new Option(`--${spec.flag} ${valueName}`, helpFor(spec, property)));
+        for (const alias of spec.entry.aliases ?? [])
+            command.addOption(new Option(`--${alias} ${valueName}`).hideHelp());
+    }
+    return command;
+}
+function invalid(flag, value, message, code = "invalid_number") {
+    return new OxygenError(code, message, { details: { flag: `--${flag}`, value }, exitCode: 1 });
+}
+function parseScalar(property, raw, flag) {
+    if (!("type" in property))
+        return raw;
+    if (property.type === "integer" || property.type === "number") {
+        const parsed = Number(raw);
+        const whole = property.type === "integer";
+        const minimum = property.minimum;
+        const ok = whole ? Number.isSafeInteger(parsed) : Number.isFinite(parsed);
+        if (!ok || (minimum !== undefined && parsed < minimum)) {
+            throw invalid(flag, raw, minimum === 0
+                ? `Expected a non-negative ${whole ? "integer" : "number"}.`
+                : `Expected ${whole ? "an integer" : "a number"}${minimum !== undefined ? ` of at least ${minimum}` : ""}.`);
+        }
+        // A clamped field is lowered (and reported) by the server; anything else over the maximum is refused here.
+        if (property.maximum !== undefined && parsed > property.maximum && !property["x-clamp"]) {
+            throw invalid(flag, raw, `Expected at most ${property.maximum}.`);
+        }
+        return parsed;
+    }
+    if (property.type === "string" && property.enum && !property.enum.includes(raw)) {
+        throw invalid(flag, raw, `--${flag} must be one of: ${property.enum.join(", ")}.`, "invalid_option");
+    }
+    return raw;
+}
+function readValue(spec, raw) {
+    if (spec.entry.parse)
+        return spec.entry.parse(raw);
+    const property = spec.property;
+    if ("type" in property && property.type === "array") {
+        return raw.split(",").map((part) => part.trim()).filter(Boolean)
+            .map((part) => parseScalar(unwrapNullable(property.items).property, part, spec.flag));
+    }
+    return parseScalar(property, raw, spec.flag);
+}
+function setPath(body, path, value) {
+    let cursor = body;
+    for (const key of path.slice(0, -1)) {
+        const next = cursor[key];
+        if (typeof next === "object" && next !== null && !Array.isArray(next))
+            cursor = next;
+        else
+            cursor = (cursor[key] = {});
+    }
+    cursor[path[path.length - 1]] = value;
+}
+function stringOption(options, flag, aliases = []) {
+    for (const name of [flag, ...aliases]) {
+        const value = options[attribute(name)];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+}
+/**
+ * The request body the parsed flags describe: only the fields given, nested as
+ * the contract nests them. An object none of whose flags was given is absent.
+ */
+export function readContractFlags(options, contract, overlay = {}) {
+    const body = {};
+    const specs = contractFlagSpecs(contract.properties, overlay);
+    const given = new Set();
+    for (const spec of specs) {
+        if (spec.kind === "value") {
+            const raw = stringOption(options, spec.flag, spec.entry.aliases);
+            if (raw === undefined)
+                continue;
+            setPath(body, spec.path, readValue(spec, raw));
+            given.add(spec.flag);
+        }
+        else if (spec.kind === "json") {
+            const raw = stringOption(options, spec.flag, spec.entry.aliases);
+            if (raw === undefined)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                throw invalid(spec.flag, raw, `--${spec.flag} must be a JSON object.`, "invalid_json");
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                throw invalid(spec.flag, raw, `--${spec.flag} must be a JSON object.`, "invalid_json");
+            }
+            setPath(body, spec.path, parsed);
+            given.add(spec.flag);
+        }
+        else if (spec.kind === "boolean") {
+            const value = options[attribute(spec.flag)];
+            if (typeof value === "boolean")
+                setPath(body, spec.path, value);
+        }
+        else if (spec.kind === "pair") {
+            if (options[attribute(spec.off)] === true)
+                setPath(body, spec.path, false);
+            else if (options[attribute(spec.on)] === true)
+                setPath(body, spec.path, true);
+        }
+        else if (options[attribute(spec.flag)] === true) {
+            if (given.has(spec.target)) {
+                throw new OxygenError("invalid_request", `Pass either --${spec.target} or --${spec.flag}, not both.`, { exitCode: 1 });
+            }
+            setPath(body, spec.path, null);
+        }
+    }
+    return body;
+}
+/** Every long flag `addContractFlags` registers, in order (for tests and docs). */
+export function contractFlagNames(contract, overlay = {}) {
+    return contractFlagSpecs(contract.properties, overlay).flatMap((spec) => {
+        switch (spec.kind) {
+            case "pair":
+                return [`--${spec.on}`, `--${spec.off}`];
+            case "boolean":
+                return [`--${spec.flag}`, `--no-${spec.flag}`];
+            case "clear":
+                return [`--${spec.flag}`];
+            default:
+                return [`--${spec.flag}`, ...(spec.entry.aliases ?? []).map((alias) => `--${alias}`)];
+        }
+    });
+}

package/dist/index.js

@@ -21,6 +21,10 @@ import { TAG_COLORS } from "@oxygen/shared/select-options";
 import { PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE } from "@oxygen/shared/plan-band";
 import { AI_COLUMN_CREDITS, AI_COLUMN_WEB_SEARCH_TYPICAL_CREDITS } from "@oxygen/shared/pricing-sheet";
 import { LINKEDIN_SENDER_LIMIT_DEFAULTS, LINKEDIN_SENDER_LIMIT_MAXIMUMS, } from "@oxygen/shared/linkedin-sequences";
+import { operationPath } from "@oxygen/shared/contracts/operations";
+import { SENDER_LIMITS_SET_OPERATION } from "@oxygen/shared/contracts/sender-limits";
+import { addContractFlags } from "./contract-flags.js";
+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";
 import { MAX_BUFFERED_IMPORT_PARSE_BYTES, assertImportFormatWithinBufferedLimit, inferImportColumnLabels, inferRowsFileFormat, normalizeImportColumnKey, normalizeRowsForNewTable, normalizeRowsFormat, parseRowsFileBuffer, parseXlsxWorkbookBuffer, } from "@oxygen/shared/file-import";
@@ -3965,9 +3969,12 @@ Examples:
         }));
     }))
         .addCommand(new Command("file")
-        .description("Create a structured, titled Plain support Thread immediately. Prefer `support chat` for an ordinary conversation; use this zero-credit filing path when explicit subject, operation, error, run, or table metadata helps triage. Check `support list --status open` first because a new filing can create a second Thread.")
+        .description("Create a structured Plain support conversation with a subject and required message. Prefer `support chat` for an ordinary conversation; use this zero-credit filing path when operation, error, run, or table metadata helps triage. A selected local transcript can be attached with --transcript-file, --session-id, or --include-transcript. Check `support list --status open` first because a new filing can create a second Thread.")
         .requiredOption("--subject <subject>", "One-line summary of the problem.")
-        .option("--body <body>", "What you were doing, what happened, and what you tried.")
+        .requiredOption("--body <body>", "Required message: what you were doing, what happened, and what you tried.")
+        .option("--include-transcript", "Attach the most recent local agent transcript after redaction.")
+        .option("--session-id <id>", "Attach this local agent session transcript.")
+        .option("--transcript-file <path>", "Attach the last 2 MB of a selected text/JSONL file after best-effort credential redaction; review it first.")
         .option("--severity <severity>", "low | normal | high. Defaults to normal.")
         .option("--category <category>", "Request type: question, bug, feature_request, billing, security_data, configuration, agency_directory, or other.")
         .option("--source <source>", "Where the ticket originated. Only slack is supported today.")
@@ -4235,7 +4242,7 @@ The final readback must show ticket.status triaging, plain_status TODO, the In p
         .description("Retired legacy write; always returns the Plain-cutover error (staff only).")
         .requiredOption("--organization <organization>", "Target organization id or slug the ticket belongs to.")
         .requiredOption("--subject <subject>", "One-line summary of the customer's request.")
-        .option("--body <body>", "The customer's request in their words, plus any staff notes.")
+        .requiredOption("--body <body>", "The customer's request in their words, plus any staff notes.")
         .option("--severity <severity>", "low | normal | high. Defaults to normal.")
         .option("--category <category>", "Optional category label, e.g. bug, feature, question.")
         .option("--source <source>", "Where the ticket originated. Only slack is supported today.")
@@ -11064,7 +11071,7 @@ Examples:
         }));
     })))
         .addCommand(new Command("invoices")
-        .description("List every invoice Stripe has issued for this workspace, newest first, each with a direct PDF link. Covers ALL charges, not just the plan — sending seats, managed inboxes, and credit top-ups appear here too, which is why this works on the free tier: a workspace with no plan can still be a paying customer. A workspace linked to another organization (`orgs billing-link`) reads its billing at that owner, so it sees an empty list and shared_billing=true; switch to the billing owner to read its invoices. pdf_url and hosted_url are Stripe's own links. Read-only, 0 Oxygen credits.")
+        .description("List every invoice Stripe has issued for this workspace, newest first, each with a direct PDF link. Covers ALL charges, not just the plan — sending seats, managed inboxes, and credit top-ups appear here too, which is why this works on the free tier: a workspace with no plan can still be a paying customer. A workspace linked to another organization (`orgs billing-link`) reads its billing at that owner, so it sees an empty list and shared_billing=true; switch to the billing owner to read its invoices. pdf_url and hosted_url are Stripe's own links. VAT or tax ID: open the web_url this command returns and choose VAT or tax ID on the Invoices card (top-up checkout also asks for it); Stripe prints it on every invoice issued after you save it, never on an earlier one. Read-only, 0 Oxygen credits.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing invoices", options, () => requestOxygen("/api/cli/billing/invoices"));
@@ -11204,7 +11211,7 @@ Examples:
         }));
     }))
         .addCommand(new Command("cancel")
-        .description("Schedule the plan subscription to cancel at period end. During a trial the card is never charged; undo any time before then with billing resume.")
+        .description("Schedule the plan subscription to cancel at period end. Free (no fee, no credits); the plan stays usable until then and the card is not charged again (during a trial, never). Prints the end date; undo any time before then with billing resume.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing cancel", options, () => requestOxygen("/api/cli/billing/cancel", {
@@ -11213,7 +11220,7 @@ Examples:
         }));
     }))
         .addCommand(new Command("resume")
-        .description("Remove a scheduled cancellation so the subscription renews (or the trial converts) normally.")
+        .description("Remove a scheduled cancellation so the subscription renews (or the trial converts) normally. Free (no fee, no credits). Prints the next charge date and amount.")
         .option("--json", "Print a JSON envelope.")
         .action(async (options) => {
         await handleAsyncAction("billing resume", options, () => requestOxygen("/api/cli/billing/cancel", {
@@ -13501,54 +13508,15 @@ Examples:
         .action(async (id, options) => {
         await handleAsyncAction("senders limits get", options, () => requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`));
     }))
-        .addCommand(new Command("set")
-        .description("Adjust per-account action limits and working hours. LinkedIn actions only run inside the account's working hours (default 07:00-22:00 every day, in the account's timezone); work due outside them is deferred to the next window, not failed. Set them with --timezone, --working-days, --working-hours-start and --working-hours-end; flags you omit keep their current value. A sequence's own schedule (sequences update --linkedin-timezone ...) can narrow the window for its LinkedIn steps, never widen it; email steps follow the sequence's email send window instead. Every limit flag shows its default and hard maximum; values above the maximum are clamped, and higher caps raise the risk of a LinkedIn restriction. Each action has its own cap (InMails per day and per rolling 30 days, profile views, profile lookups, endorsements, invitation withdrawals, posts), and every send except posts also counts toward --total-actions-per-day. Daily send caps run at half on Saturday and Sunday in the account's timezone unless --weekend-full-volume is set. A withdrawn invitation cannot be re-sent to the same person for 21 days. Own-feed posts and your own Unibox replies ignore working hours. A refused action names its reason (outside_working_hours defers it; linkedin_rate_limited names the limit and resets_at). Changing limits is free. <id> accepts a sender account id, connection id, or Unipile account id.")
-        .argument("<id>", "Sender account id, connection id, or Unipile account id.")
-        .option("--invites-per-day <n>", linkedInLimitHelp("invites_per_day", "Daily LinkedIn connection invites cap"))
-        .option("--invites-per-week <n>", linkedInLimitHelp("invites_per_week", "Weekly LinkedIn connection invites cap"))
-        .option("--messages-per-day <n>", linkedInLimitHelp("messages_per_day", "Daily direct messages cap"))
-        .option("--inmails-per-day <n>", linkedInLimitHelp("inmails_per_day", "Daily InMail cap"))
-        .option("--inmails-per-month <n>", linkedInLimitHelp("inmails_per_month", "InMail cap over a rolling 30 days"))
-        .option("--profile-views-per-day <n>", linkedInLimitHelp("profile_views_per_day", "Daily profile views cap; the member is notified"))
-        .option("--profile-lookups-per-day <n>", linkedInLimitHelp("profile_lookups_per_day", "Daily invisible profile and company lookups cap"))
-        .option("--endorsements-per-day <n>", linkedInLimitHelp("endorsements_per_day", "Daily skill endorsements cap"))
-        .option("--withdrawals-per-day <n>", linkedInLimitHelp("withdrawals_per_day", "Daily cap on withdrawing sent invitations; reading the sent list uses the read budgets"))
-        .option("--posts-per-day <n>", linkedInLimitHelp("posts_per_day", "Daily posts to the account's own feed, from every caller; not counted in the total"))
-        .option("--follows-per-day <n>", linkedInLimitHelp("follows_per_day", "Daily follows cap"))
-        .option("--likes-per-day <n>", linkedInLimitHelp("likes_per_day", "Daily likes cap"))
-        .option("--comments-per-day <n>", linkedInLimitHelp("comments_per_day", "Daily comments cap"))
-        .option("--total-actions-per-day <n>", linkedInLimitHelp("total_actions_per_day", "Daily cap across all send/action types except posts"))
-        .option("--relations-reads-per-day <n>", linkedInLimitHelp("relations_reads_per_day", "Daily cap on relations/connections list reads, the scrape ban vector"))
-        .option("--messages-reads-per-day <n>", linkedInLimitHelp("messages_reads_per_day", "Daily cap on chat and message-history reads"))
-        .option("--searches-per-day <n>", linkedInLimitHelp("searches_per_day", "Daily cap on LinkedIn search executions"))
-        .option("--sales-nav-search-results-per-day <n>", linkedInLimitHelp("sales_nav_search_results_per_day", "Daily cap on Sales Navigator search result rows fetched"))
-        .option("--api-reads-per-day <n>", linkedInLimitHelp("api_reads_per_day", "Daily cap on all other LinkedIn API reads"))
-        .option("--total-reads-per-day <n>", linkedInLimitHelp("total_reads_per_day", "Daily cap across all read units"))
-        .option("--min-spacing-seconds <n>", linkedInLimitHelp("min_action_spacing_seconds", "Minimum seconds between actions"))
-        .option("--spacing-jitter-seconds <n>", linkedInLimitHelp("action_spacing_jitter_seconds", "Random jitter seconds added to action spacing"))
-        .option("--interactive-min-spacing-seconds <n>", linkedInLimitHelp("interactive_min_spacing_seconds", "Minimum seconds between human-sent Unibox actions"))
-        .option("--interactive-spacing-jitter-seconds <n>", linkedInLimitHelp("interactive_spacing_jitter_seconds", "Random jitter seconds added to human-sent Unibox action spacing"))
-        .option("--interactive-sends-per-hour <n>", linkedInLimitHelp("interactive_sends_per_hour", "Hourly cap on human-sent Unibox actions"))
-        .option("--timezone <tz>", "IANA timezone for the working hours and the daily counter reset, e.g. Europe/Berlin. Defaults to the zone of the country chosen at connect.")
-        .option("--working-days <days>", "Days LinkedIn actions may run: mon-fri, mon,wed,fri, or ISO numbers 1-7 (1 = Monday). A weekday-only window leaves a visible two-day gap every week.")
-        .option("--working-hours-start <HH:MM>", "Local time working hours start, e.g. 09:00.")
-        .option("--working-hours-end <HH:MM>", "Local time working hours end (exclusive), e.g. 18:00. Must be after the start.")
-        .option("--warmup-restart", "Start (or restart) the warm-up ramp now — gradually raises this account's invite + message caps to full over ~2 weeks.")
-        .option("--warmup-disable", "Turn off warm-up for this account (treat it as already warm and use its full configured caps).")
-        .option("--read-warmup-disable", "Turn off the READ warm-up ramp for this account. Network capture (`oxygen linkedin network setup`) eases a newly armed account in at 5 \u2192 10 \u2192 20 reads a day over two weeks; this runs it at the full read budget immediately. Separate from --warmup-disable, which governs invites and messages.")
-        .option("--read-warmup-restart", "Restart the READ warm-up ramp from today, so network capture eases back in from 5 reads a day. Also clears --read-warmup-disable.")
-        .option("--warmup-start-date <date>", "Set the warm-up start date (ISO, e.g. 2026-01-31). A past date credits prior warming and advances the ramp.")
-        .option("--warmup-preset <preset>", "Warm-up ramp curve: conservative (~3 weeks), standard (~2 weeks, default), or fast (~1 week for an aged account).")
-        .option("--randomize-caps", "Randomise this account's daily send caps to 80-100% of configured so daily volume varies instead of hitting the same cap every day.")
-        .option("--no-randomize-caps", "Turn off randomised daily caps (use the exact configured caps every day).")
-        .option("--weekend-full-volume", "Keep full daily send caps on Saturday and Sunday (by default they run at half).")
-        .option("--no-weekend-full-volume", "Run daily send caps at half on Saturday and Sunday again (the default).")
+        .addCommand(addContractFlags(new Command(SENDER_LIMITS_SET_OPERATION.cli.path.at(-1) ?? "set")
+        .description(SENDER_LIMITS_SET_OPERATION.cli.summary)
+        .argument("<id>", SENDER_LIMITS_SET_OPERATION.cli.argument?.description), SENDER_LIMITS_SET_OPERATION.contract, SENDER_LIMITS_FLAG_OVERLAY)
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("senders limits set", options, () => {
-            const body = buildLinkedinLimitsBody(options);
-            return requestOxygen(`/api/cli/senders/${encodeURIComponent(id)}/limits`, {
-                method: "PATCH",
+            const body = buildSenderLimitsBody(options);
+            return requestOxygen(operationPath(SENDER_LIMITS_SET_OPERATION, { id }), {
+                method: SENDER_LIMITS_SET_OPERATION.method,
                 body,
             });
         });
@@ -14408,7 +14376,7 @@ Examples:
         .option("--json", "Print a JSON envelope.")
         .action(async (id, options) => {
         await handleAsyncAction("whatsapp limits set", options, () => {
-            const body = buildLinkedinLimitsBody(options);
+            const body = buildSenderLimitsBody(options);
             return requestOxygen(`/api/cli/whatsapp/accounts/${encodeURIComponent(id)}/limits`, {
                 method: "PATCH",
                 body,
@@ -27572,9 +27540,29 @@ function buildFeedbackBody(options) {
     return body;
 }
 function buildSupportTicketBody(options) {
-    const body = { subject: readOption(options.subject) };
-    if (readOption(options.body))
-        body.body = readOption(options.body);
+    const message = readOption(options.body);
+    if (!message) {
+        throw new OxygenError("invalid_input", 'Provide a support message with --body "...".', { exitCode: 1 });
+    }
+    const body = { subject: readOption(options.subject), body: message };
+    const sessionId = readOption(options.sessionId);
+    const file = readOption(options.transcriptFile);
+    if (options.includeTranscript || sessionId || file) {
+        try {
+            const captured = captureCurrentTranscript({ sessionId, file });
+            if (!captured) {
+                throw new OxygenError("transcript_not_found", "No local agent transcript was found. Choose --session-id or --transcript-file.", { exitCode: 1 });
+            }
+            const { path: _path, ...payload } = captured;
+            body.transcript = payload;
+        }
+        catch (error) {
+            if (error instanceof TranscriptCaptureError) {
+                throw new OxygenError("transcript_not_found", error.message, { exitCode: 1 });
+            }
+            throw error;
+        }
+    }
     if (readOption(options.severity))
         body.severity = readOption(options.severity);
     if (readOption(options.category))
@@ -28692,110 +28680,6 @@ table, options) {
         ...(options.onlyMissing ? { only_missing: true } : {}),
     };
 }
-/** "<text> (default N, max M)." for a LinkedIn sender limit flag, from the enforced constants. */
-function linkedInLimitHelp(key, text) {
-    return `${text} (default ${LINKEDIN_SENDER_LIMIT_DEFAULTS[key]}, max ${LINKEDIN_SENDER_LIMIT_MAXIMUMS[key]}).`;
-}
-function buildLinkedinLimitsBody(// skipcq: JS-R1005 -- CLI body builder maps per-account limit flags + reset timezone.
-options) {
-    const limits = {};
-    const setLimit = (key, value) => {
-        const parsed = readNonNegativeInt(value);
-        if (parsed !== undefined)
-            limits[key] = parsed;
-    };
-    setLimit("invites_per_day", options.invitesPerDay);
-    setLimit("invites_per_week", options.invitesPerWeek);
-    setLimit("messages_per_day", options.messagesPerDay);
-    setLimit("inmails_per_day", options.inmailsPerDay);
-    setLimit("inmails_per_month", options.inmailsPerMonth);
-    setLimit("profile_views_per_day", options.profileViewsPerDay);
-    setLimit("profile_lookups_per_day", options.profileLookupsPerDay);
-    setLimit("endorsements_per_day", options.endorsementsPerDay);
-    setLimit("withdrawals_per_day", options.withdrawalsPerDay);
-    setLimit("posts_per_day", options.postsPerDay);
-    setLimit("follows_per_day", options.followsPerDay);
-    setLimit("likes_per_day", options.likesPerDay);
-    setLimit("comments_per_day", options.commentsPerDay);
-    setLimit("total_actions_per_day", options.totalActionsPerDay);
-    setLimit("relations_reads_per_day", options.relationsReadsPerDay);
-    setLimit("messages_reads_per_day", options.messagesReadsPerDay);
-    setLimit("searches_per_day", options.searchesPerDay);
-    setLimit("sales_nav_search_results_per_day", options.salesNavSearchResultsPerDay);
-    setLimit("api_reads_per_day", options.apiReadsPerDay);
-    setLimit("total_reads_per_day", options.totalReadsPerDay);
-    setLimit("min_action_spacing_seconds", options.minSpacingSeconds);
-    setLimit("action_spacing_jitter_seconds", options.spacingJitterSeconds);
-    setLimit("interactive_min_spacing_seconds", options.interactiveMinSpacingSeconds);
-    setLimit("interactive_spacing_jitter_seconds", options.interactiveSpacingJitterSeconds);
-    setLimit("interactive_sends_per_hour", options.interactiveSendsPerHour);
-    // Working hours: only the given fields are sent; the server merges them into
-    // the stored window and validates the result (invalid_working_hours).
-    const workingHours = {};
-    const timezone = readOption(options.timezone);
-    if (timezone)
-        workingHours.timezone = timezone;
-    const workingDays = readOption(options.workingDays);
-    if (workingDays)
-        workingHours.days = parseWorkingDaysOption(workingDays);
-    const workingHoursStart = readOption(options.workingHoursStart);
-    if (workingHoursStart)
-        workingHours.start = workingHoursStart;
-    const workingHoursEnd = readOption(options.workingHoursEnd);
-    if (workingHoursEnd)
-        workingHours.end = workingHoursEnd;
-    // Warm-up override (LinkedIn only). A start-date wins over the booleans; the
-    // WhatsApp `set` command doesn't expose these flags, so this stays empty there.
-    let warmup;
-    const warmupStartDate = readOption(options.warmupStartDate);
-    if (warmupStartDate) {
-        warmup = { start_date: warmupStartDate };
-    }
-    else if (options.warmupDisable) {
-        warmup = { enabled: false };
-    }
-    else if (options.warmupRestart) {
-        warmup = { enabled: true };
-    }
-    // Opinionated-safety knobs (P3): the warm-up preset curve + randomised daily caps.
-    const warmupPreset = readOption(options.warmupPreset);
-    const hasPreset = warmupPreset !== null && warmupPreset !== undefined;
-    const hasRandomize = options.randomizeCaps !== undefined;
-    const hasWeekendFullVolume = options.weekendFullVolume !== undefined;
-    // The READ ramp is a separate axis from the send-side warm-up above: it is
-    // default-on, anchored on when network capture was armed, and governs read
-    // budgets only. Disabling one must never disable the other.
-    const readWarmup = options.readWarmupDisable
-        ? false
-        : options.readWarmupRestart
-            ? true
-            : undefined;
-    const hasLimits = Object.keys(limits).length > 0;
-    const hasWorkingHours = Object.keys(workingHours).length > 0;
-    const hasWarmup = warmup !== undefined;
-    const hasReadWarmup = readWarmup !== undefined;
-    if (!hasLimits && !hasWorkingHours && !hasWarmup && !hasPreset && !hasRandomize && !hasReadWarmup && !hasWeekendFullVolume) {
-        throw new OxygenError("invalid_request", "Pass at least one limit flag (e.g. --invites-per-day), a working-hours flag (--timezone, --working-days, --working-hours-start, --working-hours-end), a warm-up flag (--warmup-restart / --warmup-disable / --warmup-start-date), --read-warmup-disable / --read-warmup-restart, --warmup-preset, --randomize-caps, or --weekend-full-volume.", { exitCode: 1 });
-    }
-    return {
-        ...(hasLimits ? { limits } : {}),
-        ...(hasWorkingHours ? { working_hours: workingHours } : {}),
-        ...(hasWarmup ? { warmup } : {}),
-        ...(hasPreset ? { warmup_preset: warmupPreset } : {}),
-        ...(hasRandomize ? { randomize_daily_caps: options.randomizeCaps } : {}),
-        ...(hasWeekendFullVolume ? { weekend_full_volume: options.weekendFullVolume } : {}),
-        ...(hasReadWarmup ? { read_warmup: readWarmup } : {}),
-    };
-}
-const WORKING_DAY_NAMES = {
-    mon: 1, monday: 1, tue: 2, tues: 2, tuesday: 2, wed: 3, wednesday: 3, thu: 4, thur: 4, thurs: 4, thursday: 4,
-    fri: 5, friday: 5, sat: 6, saturday: 6, sun: 7, sunday: 7,
-};
-/**
- * `--working-days` → ISO weekday numbers. Accepts day names or 1-7, comma
- * separated, and ranges (`mon-fri`, `1-5`). A token it cannot read is sent as
- * given so the server's invalid_working_hours error names it.
- */
 // The four --linkedin-* flags write settings.schedule, the per-sequence window
 // the LinkedIn/WhatsApp dispatcher enforces on top of each sender's working
 // hours. The server stores the window whole, so the four flags go together.
@@ -28811,31 +28695,6 @@ function readLinkedinScheduleOptions(options) {
     }
     return { timezone, days: parseWorkingDaysOption(days), start, end };
 }
-function parseWorkingDaysOption(value) {
-    const day = (token) => {
-        const lower = token.trim().toLowerCase();
-        if (/^[1-7]$/.test(lower))
-            return Number(lower);
-        return WORKING_DAY_NAMES[lower] ?? null;
-    };
-    const days = [];
-    for (const token of value.split(",").map((part) => part.trim()).filter(Boolean)) {
-        const [from, to, ...rest] = token.split("-");
-        const start = from !== undefined ? day(from) : null;
-        const end = to !== undefined ? day(to) : null;
-        if (rest.length === 0 && start !== null && end !== null && start <= end) {
-            for (let current = start; current <= end; current += 1)
-                days.push(current);
-        }
-        else if (to === undefined && start !== null) {
-            days.push(start);
-        }
-        else {
-            days.push(token);
-        }
-    }
-    return days;
-}
 /**
  * A whole seat count. Unlike readPositiveNumber, ZERO IS VALID and meaningful:
  * `--quantity 0` is how a customer gives back every seat of a channel, and

package/dist/sender-limits-flags.d.ts

@@ -0,0 +1,14 @@
+import { type ContractFlagOverlay } from "./contract-flags.js";
+/**
+ * `--working-days` → ISO weekday numbers. Accepts day names or 1-7, comma
+ * separated, and ranges (`mon-fri`, `1-5`). A token it cannot read is sent as
+ * given so the server's invalid_working_hours error names it.
+ */
+export declare function parseWorkingDaysOption(value: string): unknown[];
+export declare const SENDER_LIMITS_FLAG_OVERLAY: ContractFlagOverlay;
+/**
+ * The limits PATCH body for the flags given. A warm-up start date wins over
+ * --warmup-restart/--warmup-disable (the route reads it first anyway), so the
+ * body carries only the one it will act on. Throws when no flag was given.
+ */
+export declare function buildSenderLimitsBody(options: Record<string, unknown>): Record<string, unknown>;