@oxygen-agent/cli 1.1010.721 → 1.1010.950

package/node_modules/@oxygen/shared/dist/contracts/operations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One entry per customer operation that edits a resource: the route it calls,
+ * the contract its body satisfies, and the names it carries on the CLI and MCP.
+ * The CLI command, the MCP tool and the route read the same spec, so the three
+ * cannot disagree on which fields exist. Leaf and browser-safe.
+ */
+import type { ContractObject } from "./schema.js";
+export type OperationSpec<C extends ContractObject = ContractObject> = {
+    /** Stable id, `<resource>.<verb>`. */
+    id: string;
+    /** Route template; `{name}` segments are path parameters. */
+    route: string;
+    method: "POST" | "PATCH";
+    /** When set, the contract describes `body[bodyKey]` rather than the whole body. */
+    bodyKey?: string;
+    contract: C;
+    cli: {
+        /** Command words after `oxygen`, e.g. `["senders", "limits", "set"]`. */
+        path: readonly string[];
+        summary: string;
+        /** The positional argument that fills the route's single path parameter. */
+        argument?: {
+            name: string;
+            description: string;
+        };
+    };
+    mcp: {
+        name: string;
+        title: string;
+        description: string;
+        /** The MCP toolset domain (pack) the tool registers under. */
+        pack: string;
+    };
+    mutates: boolean;
+    spends: boolean;
+};
+/** The route with its `{param}` segments filled in, each URL-encoded. */
+export declare function operationPath(spec: Pick<OperationSpec, "route">, params: Readonly<Record<string, string>>): string;
+export declare const OPERATION_SPECS: readonly OperationSpec[];

package/node_modules/@oxygen/shared/dist/contracts/operations.js

@@ -0,0 +1,11 @@
+import { SENDER_LIMITS_SET_OPERATION } from "./sender-limits.js";
+/** The route with its `{param}` segments filled in, each URL-encoded. */
+export function operationPath(spec, params) {
+    return spec.route.replace(/\{(\w+)\}/g, (_match, name) => {
+        const value = params[name];
+        if (value === undefined)
+            throw new Error(`Missing path parameter ${name} for ${spec.route}`);
+        return encodeURIComponent(value);
+    });
+}
+export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION];

package/node_modules/@oxygen/shared/dist/contracts/schema.d.ts

@@ -0,0 +1,186 @@
+/**
+ * One contract per editable resource, in the plain JSON-schema dialect MCP tool
+ * input schemas already use (founder decision 2026-09-28: no zod, no new
+ * dependency). The same object generates the CLI flags
+ * (`packages/cli/src/contract-flags.ts`), the MCP input schema
+ * (`packages/mcp-server/src/tools/contract-tool.ts`) and validates the API
+ * route body (`validateContract`), so a field cannot exist on one surface and
+ * not another.
+ *
+ * Leaf and browser-safe: no imports, no IO.
+ */
+export type StringProperty = {
+    type: "string";
+    description?: string;
+    enum?: readonly string[];
+    minLength?: number;
+    maxLength?: number;
+};
+export type NumberProperty = {
+    type: "number" | "integer";
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    /**
+     * The route clamps a value above `maximum` down to it instead of refusing
+     * it, when `validateContract` runs with `overMax: "clamp"`. Annotation only:
+     * `contractToolProperties` strips it from the MCP schema.
+     */
+    "x-clamp"?: true;
+};
+export type BooleanProperty = {
+    type: "boolean";
+    description?: string;
+};
+export type NullProperty = {
+    type: "null";
+};
+export interface ArrayProperty<I extends JsonProperty = JsonProperty> {
+    type: "array";
+    description?: string;
+    items: I;
+    minItems?: number;
+    maxItems?: number;
+}
+export interface ObjectProperty<P extends Record<string, JsonProperty> = Record<string, JsonProperty>> {
+    type: "object";
+    description?: string;
+    additionalProperties?: boolean | JsonProperty;
+    properties?: P;
+    required?: readonly string[];
+}
+export interface OneOfProperty {
+    oneOf: JsonProperty[];
+    description?: string;
+}
+export type JsonProperty = {
+    $ref: string;
+} | StringProperty | NumberProperty | BooleanProperty | NullProperty | ObjectProperty | ArrayProperty | OneOfProperty;
+/** The top level of a contract: a closed object. */
+export type ContractObject<P extends Record<string, JsonProperty> = Record<string, JsonProperty>, R extends string = string> = {
+    type: "object";
+    description?: string;
+    additionalProperties: false;
+    properties: P;
+    required?: readonly R[];
+};
+type Described = {
+    description?: string;
+};
+type NumberOptions = Described & {
+    minimum?: number;
+    maximum?: number;
+    clamp?: boolean;
+};
+export declare function int(options?: NumberOptions): {
+    type: "integer";
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    "x-clamp"?: true;
+};
+export declare function num(options?: NumberOptions): {
+    type: "number";
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    "x-clamp"?: true;
+};
+export declare function bool(options?: Described): BooleanProperty;
+export declare function str(options?: Described & {
+    minLength?: number;
+    maxLength?: number;
+}): StringProperty;
+export declare function enumOf<const V extends string>(values: readonly V[], options?: Described): {
+    type: "string";
+    enum: readonly V[];
+    description?: string;
+};
+export declare function arr<const I extends JsonProperty>(items: I, options?: Described & {
+    minItems?: number;
+    maxItems?: number;
+}): ArrayProperty<I>;
+export declare function obj<const P extends Record<string, JsonProperty>, const R extends keyof P & string = never>(properties: P, options?: Described & {
+    required?: readonly R[];
+}): ContractObject<P, R>;
+/** `null` is accepted and passed through; it means "clear this field". */
+export declare function nullable<const P extends JsonProperty>(property: P): {
+    oneOf: [P, NullProperty];
+    description?: string;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type InferObject<M, R> = Simplify<{
+    [K in keyof M as K extends R ? K : never]: Infer<M[K]>;
+} & {
+    [K in keyof M as K extends R ? never : K]?: Infer<M[K]>;
+}>;
+/** The TypeScript type of a value that passes `validateContract`. Fields not in `required` are optional. */
+export type Infer<P> = P extends {
+    oneOf: readonly [infer A, NullProperty];
+} ? Infer<A> | null : P extends {
+    type: "integer" | "number";
+} ? number : P extends {
+    type: "boolean";
+} ? boolean : P extends {
+    type: "string";
+    enum: readonly (infer E)[];
+} ? E : P extends {
+    type: "string";
+} ? string : P extends {
+    type: "array";
+    items: infer I;
+} ? Infer<I>[] : P extends {
+    type: "object";
+    properties: infer M;
+} ? InferObject<M, P extends {
+    required?: readonly (infer R)[];
+} ? R : never> : unknown;
+/** A property's non-null branch, and whether null is allowed. */
+export declare function unwrapNullable(property: JsonProperty): {
+    property: JsonProperty;
+    nullable: boolean;
+};
+export type ContractLeaf = {
+    /** Dotted path, e.g. `limits.invites_per_day`. */
+    key: string;
+    path: readonly string[];
+    /** The leaf's non-null schema. */
+    property: JsonProperty;
+    nullable: boolean;
+};
+/** Every non-object field of a contract, depth first in declaration order. */
+export declare function contractLeafPaths(contract: ContractObject | ObjectProperty, prefix?: readonly string[]): ContractLeaf[];
+export type ContractIssue = {
+    path: string;
+    message: string;
+};
+export type ValidateContractOptions = {
+    /**
+     * `warn`: an unknown key is listed in `unknownKeys` AND kept in `value`, so a
+     * route that still reads it behaves exactly as before the contract existed.
+     * `reject`: an unknown key is an issue.
+     */
+    unknown: "warn" | "reject";
+    /** `clamp` lowers an over-maximum value to the maximum, only where the field carries `x-clamp`. */
+    overMax: "clamp" | "reject";
+};
+export type ContractValidation<T> = {
+    ok: true;
+    value: T;
+    unknownKeys: string[];
+    clamped: string[];
+} | {
+    ok: false;
+    issues: ContractIssue[];
+};
+/**
+ * Check a request body against its contract. Absent (`undefined`) fields are
+ * skipped, `null` passes only where the field is `nullable`, and every issue is
+ * collected rather than stopping at the first. On success `value` is a copy with
+ * clamps applied (see the options for what happens to unknown keys).
+ */
+export declare function validateContract<C extends ContractObject>(contract: C, value: unknown, options: ValidateContractOptions): ContractValidation<Infer<C>>;
+export {};

package/node_modules/@oxygen/shared/dist/contracts/schema.js

@@ -0,0 +1,260 @@
+/**
+ * One contract per editable resource, in the plain JSON-schema dialect MCP tool
+ * input schemas already use (founder decision 2026-09-28: no zod, no new
+ * dependency). The same object generates the CLI flags
+ * (`packages/cli/src/contract-flags.ts`), the MCP input schema
+ * (`packages/mcp-server/src/tools/contract-tool.ts`) and validates the API
+ * route body (`validateContract`), so a field cannot exist on one surface and
+ * not another.
+ *
+ * Leaf and browser-safe: no imports, no IO.
+ */
+function described(shape, description) {
+    return description === undefined ? shape : { ...shape, description };
+}
+function numeric(type, options = {}) {
+    const { description, minimum, maximum, clamp } = options;
+    return {
+        type,
+        ...(minimum !== undefined ? { minimum } : {}),
+        ...(maximum !== undefined ? { maximum } : {}),
+        ...(clamp ? { "x-clamp": true } : {}),
+        ...(description !== undefined ? { description } : {}),
+    };
+}
+export function int(options) {
+    return numeric("integer", options);
+}
+export function num(options) {
+    return numeric("number", options);
+}
+export function bool(options = {}) {
+    return described({ type: "boolean" }, options.description);
+}
+export function str(options = {}) {
+    const { description, ...rest } = options;
+    return described({ type: "string", ...rest }, description);
+}
+export function enumOf(values, options = {}) {
+    return described({ type: "string", enum: values }, options.description);
+}
+export function arr(items, options = {}) {
+    const { description, ...rest } = options;
+    return described({ type: "array", items, ...rest }, description);
+}
+export function obj(properties, options = {}) {
+    const { description, required } = options;
+    return {
+        type: "object",
+        ...(description !== undefined ? { description } : {}),
+        additionalProperties: false,
+        properties,
+        ...(required && required.length > 0 ? { required } : {}),
+    };
+}
+/** `null` is accepted and passed through; it means "clear this field". */
+export function nullable(property) {
+    const { description, ...inner } = property;
+    return {
+        oneOf: [inner, { type: "null" }],
+        ...(description !== undefined ? { description } : {}),
+    };
+}
+/** A property's non-null branch, and whether null is allowed. */
+export function unwrapNullable(property) {
+    if ("oneOf" in property && property.oneOf.length === 2) {
+        const nonNull = property.oneOf.filter((branch) => !("type" in branch && branch.type === "null"));
+        if (nonNull.length === 1) {
+            const inner = nonNull[0];
+            return {
+                property: property.description !== undefined && !("$ref" in inner)
+                    ? { ...inner, description: property.description }
+                    : inner,
+                nullable: true,
+            };
+        }
+    }
+    return { property, nullable: false };
+}
+/** Every non-object field of a contract, depth first in declaration order. */
+export function contractLeafPaths(contract, prefix = []) {
+    const leaves = [];
+    for (const [name, raw] of Object.entries(contract.properties ?? {})) {
+        const path = [...prefix, name];
+        const { property, nullable } = unwrapNullable(raw);
+        if ("type" in property && property.type === "object" && property.properties) {
+            leaves.push(...contractLeafPaths(property, path));
+        }
+        else {
+            leaves.push({ key: path.join("."), path, property, nullable });
+        }
+    }
+    return leaves;
+}
+function kindOf(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const TYPE_NOUN = {
+    integer: "a whole number",
+    number: "a number",
+    string: "a string",
+    boolean: "true or false",
+    array: "a list",
+    object: "an object",
+};
+function childPath(parent, key) {
+    return parent ? `${parent}.${key}` : key;
+}
+function walkObject(schema, value, path, walk) {
+    const out = {};
+    const properties = schema.properties ?? {};
+    for (const key of schema.required ?? []) {
+        if (value[key] === undefined)
+            walk.issues.push({ path: childPath(path, key), message: `${childPath(path, key)} is required.` });
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry === undefined)
+            continue;
+        const at = childPath(path, key);
+        const property = properties[key];
+        if (property !== undefined) {
+            out[key] = walkValue(property, entry, at, walk);
+            continue;
+        }
+        const extra = schema.additionalProperties;
+        if (extra === false) {
+            if (walk.options.unknown === "reject") {
+                walk.issues.push({ path: at, message: `${at} is not a recognised field.` });
+            }
+            else {
+                walk.unknownKeys.push(at);
+                out[key] = entry;
+            }
+        }
+        else if (extra && typeof extra === "object") {
+            out[key] = walkValue(extra, entry, at, walk);
+        }
+        else {
+            out[key] = entry;
+        }
+    }
+    return out;
+}
+function walkValue(schema, value, path, walk) {
+    if ("$ref" in schema)
+        return value;
+    if ("oneOf" in schema) {
+        const { property, nullable } = unwrapNullable(schema);
+        if (value === null) {
+            if (nullable)
+                return null;
+            walk.issues.push({ path, message: `${path} must not be null.` });
+            return value;
+        }
+        if (nullable)
+            return walkValue(property, value, path, walk);
+        for (const branch of schema.oneOf) {
+            const trial = { options: walk.options, issues: [], unknownKeys: [], clamped: [] };
+            const result = walkValue(branch, value, path, trial);
+            if (trial.issues.length === 0) {
+                walk.unknownKeys.push(...trial.unknownKeys);
+                walk.clamped.push(...trial.clamped);
+                return result;
+            }
+        }
+        walk.issues.push({ path, message: `${path} does not match any accepted shape.` });
+        return value;
+    }
+    if (schema.type === "null") {
+        if (value !== null)
+            walk.issues.push({ path, message: `${path} must be null.` });
+        return value;
+    }
+    if (value === null) {
+        walk.issues.push({ path, message: `${path} must not be null.` });
+        return value;
+    }
+    const mismatch = () => {
+        walk.issues.push({ path, message: `${path} must be ${TYPE_NOUN[schema.type]}, not ${kindOf(value)}.` });
+        return value;
+    };
+    switch (schema.type) {
+        case "boolean":
+            return typeof value === "boolean" ? value : mismatch();
+        case "string": {
+            if (typeof value !== "string")
+                return mismatch();
+            if (schema.enum && !schema.enum.includes(value)) {
+                walk.issues.push({ path, message: `${path} must be one of: ${schema.enum.join(", ")}.` });
+            }
+            else if (schema.minLength !== undefined && value.length < schema.minLength) {
+                walk.issues.push({ path, message: `${path} must be at least ${schema.minLength} characters.` });
+            }
+            else if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+                walk.issues.push({ path, message: `${path} must be at most ${schema.maxLength} characters.` });
+            }
+            return value;
+        }
+        case "integer":
+        case "number": {
+            if (typeof value !== "number" || !Number.isFinite(value))
+                return mismatch();
+            if (schema.type === "integer" && !Number.isInteger(value))
+                return mismatch();
+            if (schema.minimum !== undefined && value < schema.minimum) {
+                walk.issues.push({ path, message: `${path} must be at least ${schema.minimum}.` });
+                return value;
+            }
+            if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
+                walk.issues.push({ path, message: `${path} must be greater than ${schema.exclusiveMinimum}.` });
+                return value;
+            }
+            if (schema.maximum !== undefined && value > schema.maximum) {
+                if (schema["x-clamp"] && walk.options.overMax === "clamp") {
+                    walk.clamped.push(path);
+                    return schema.maximum;
+                }
+                walk.issues.push({ path, message: `${path} must be at most ${schema.maximum}.` });
+            }
+            return value;
+        }
+        case "array": {
+            if (!Array.isArray(value))
+                return mismatch();
+            if (schema.minItems !== undefined && value.length < schema.minItems) {
+                walk.issues.push({ path, message: `${path} must list at least ${schema.minItems}.` });
+            }
+            else if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+                walk.issues.push({ path, message: `${path} must list at most ${schema.maxItems}.` });
+            }
+            return value.map((item, index) => walkValue(schema.items, item, `${path}[${index}]`, walk));
+        }
+        case "object":
+            return isRecord(value) ? walkObject(schema, value, path, walk) : mismatch();
+        default:
+            return value;
+    }
+}
+/**
+ * Check a request body against its contract. Absent (`undefined`) fields are
+ * skipped, `null` passes only where the field is `nullable`, and every issue is
+ * collected rather than stopping at the first. On success `value` is a copy with
+ * clamps applied (see the options for what happens to unknown keys).
+ */
+export function validateContract(contract, value, options) {
+    const walk = { options, issues: [], unknownKeys: [], clamped: [] };
+    if (!isRecord(value)) {
+        return { ok: false, issues: [{ path: "", message: "The request body must be a JSON object." }] };
+    }
+    const out = walkObject(contract, value, "", walk);
+    if (walk.issues.length > 0)
+        return { ok: false, issues: walk.issues };
+    return { ok: true, value: out, unknownKeys: walk.unknownKeys, clamped: walk.clamped };
+}

package/node_modules/@oxygen/shared/dist/contracts/sender-limits.d.ts

@@ -0,0 +1,67 @@
+import type { OperationSpec } from "./operations.js";
+import { type Infer } from "./schema.js";
+export declare const SENDER_LIMITS_CONTRACT: import("./schema.js").ContractObject<Record<"action_spacing_jitter_seconds" | "api_ingest_reads_per_day" | "api_reads_per_day" | "comments_per_day" | "endorsements_per_day" | "follows_per_day" | "inmails_per_day" | "inmails_per_month" | "interactive_min_spacing_seconds" | "interactive_sends_per_hour" | "interactive_spacing_jitter_seconds" | "invites_per_day" | "invites_per_week" | "likes_per_day" | "messages_ingest_reads_per_day" | "messages_per_day" | "messages_reads_per_day" | "min_action_spacing_seconds" | "network_backfill_reads_per_day" | "network_delta_reads_per_day" | "posts_per_day" | "profile_lookups_per_day" | "profile_views_per_day" | "relations_ingest_reads_per_day" | "relations_reads_per_day" | "sales_nav_search_results_per_day" | "searches_per_day" | "total_actions_per_day" | "total_reads_per_day" | "withdrawals_per_day", {
+    type: "integer";
+    description?: string;
+    minimum?: number;
+    maximum?: number;
+    "x-clamp"?: true;
+}>, never>;
+export declare const SENDER_WORKING_HOURS_CONTRACT: import("./schema.js").ContractObject<{
+    readonly timezone: import("./schema.js").StringProperty;
+    readonly days: import("./schema.js").ArrayProperty<{
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    }>;
+    readonly start: import("./schema.js").StringProperty;
+    readonly end: import("./schema.js").StringProperty;
+}, never>;
+export declare const SENDER_WARMUP_CONTRACT: import("./schema.js").ContractObject<{
+    readonly enabled: import("./schema.js").BooleanProperty;
+    readonly start_date: {
+        oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+        description?: string;
+    };
+}, never>;
+export declare const LINKEDIN_WARMUP_PRESETS: readonly ["conservative", "standard", "fast"];
+export declare const SENDER_LIMITS_PATCH_CONTRACT: import("./schema.js").ContractObject<{
+    readonly limits: import("./schema.js").ContractObject<Record<"action_spacing_jitter_seconds" | "api_ingest_reads_per_day" | "api_reads_per_day" | "comments_per_day" | "endorsements_per_day" | "follows_per_day" | "inmails_per_day" | "inmails_per_month" | "interactive_min_spacing_seconds" | "interactive_sends_per_hour" | "interactive_spacing_jitter_seconds" | "invites_per_day" | "invites_per_week" | "likes_per_day" | "messages_ingest_reads_per_day" | "messages_per_day" | "messages_reads_per_day" | "min_action_spacing_seconds" | "network_backfill_reads_per_day" | "network_delta_reads_per_day" | "posts_per_day" | "profile_lookups_per_day" | "profile_views_per_day" | "relations_ingest_reads_per_day" | "relations_reads_per_day" | "sales_nav_search_results_per_day" | "searches_per_day" | "total_actions_per_day" | "total_reads_per_day" | "withdrawals_per_day", {
+        type: "integer";
+        description?: string;
+        minimum?: number;
+        maximum?: number;
+        "x-clamp"?: true;
+    }>, never>;
+    readonly working_hours: import("./schema.js").ContractObject<{
+        readonly timezone: import("./schema.js").StringProperty;
+        readonly days: import("./schema.js").ArrayProperty<{
+            type: "integer";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        }>;
+        readonly start: import("./schema.js").StringProperty;
+        readonly end: import("./schema.js").StringProperty;
+    }, never>;
+    readonly warmup: import("./schema.js").ContractObject<{
+        readonly enabled: import("./schema.js").BooleanProperty;
+        readonly start_date: {
+            oneOf: [import("./schema.js").StringProperty, import("./schema.js").NullProperty];
+            description?: string;
+        };
+    }, never>;
+    readonly read_warmup: import("./schema.js").BooleanProperty;
+    readonly warmup_preset: {
+        type: "string";
+        enum: readonly ("conservative" | "fast" | "standard")[];
+        description?: string;
+    };
+    readonly randomize_daily_caps: import("./schema.js").BooleanProperty;
+    readonly weekend_full_volume: import("./schema.js").BooleanProperty;
+}, never>;
+export type SenderLimitsPatch = Infer<typeof SENDER_LIMITS_PATCH_CONTRACT>;
+export declare const SENDER_LIMITS_SET_OPERATION: OperationSpec<typeof SENDER_LIMITS_PATCH_CONTRACT>;

package/node_modules/@oxygen/shared/dist/contracts/sender-limits.js

@@ -0,0 +1,88 @@
+/**
+ * `PATCH /api/cli/senders/{id}/limits`: per-account LinkedIn caps, working
+ * hours, the warm-up ramp and the account's safety knobs. Mirrors exactly what
+ * the route accepts; the route's own validators (working-hours rules, warm-up
+ * date parsing) still run after the contract.
+ */
+import { LINKEDIN_SENDER_LIMIT_DEFAULTS, LINKEDIN_SENDER_LIMIT_KEYS, LINKEDIN_SENDER_LIMIT_MAXIMUMS, } from "../linkedin-sequences.js";
+import { arr, bool, enumOf, int, nullable, obj, str } from "./schema.js";
+/** Short MCP-facing notes; the CLI carries its own longer help per flag. */
+const LIMIT_NOTES = {
+    inmails_per_month: "Rolling 30 days.",
+    profile_lookups_per_day: "Invisible profile/company lookups.",
+    withdrawals_per_day: "Sent-invite withdrawals.",
+    posts_per_day: "Own-feed posts.",
+    total_actions_per_day: "All sends except posts.",
+    relations_reads_per_day: "Connection-list reads.",
+    messages_reads_per_day: "Message-history reads.",
+    sales_nav_search_results_per_day: "Result rows.",
+    api_reads_per_day: "Other API reads.",
+    total_reads_per_day: "All reads.",
+    interactive_min_spacing_seconds: "Human Unibox send spacing.",
+    interactive_spacing_jitter_seconds: "Jitter on that spacing.",
+    interactive_sends_per_hour: "Hourly human send cap.",
+    relations_ingest_reads_per_day: "Background connection/follower list reads.",
+    api_ingest_reads_per_day: "Background engagement and post-metric reads.",
+    messages_ingest_reads_per_day: "Background message-history backfill.",
+    network_backfill_reads_per_day: "Network capture, first walk.",
+    network_delta_reads_per_day: "Network capture, once walked.",
+};
+function limit(key) {
+    const max = LINKEDIN_SENDER_LIMIT_MAXIMUMS[key];
+    const note = LIMIT_NOTES[key];
+    return int({
+        minimum: 0,
+        maximum: max,
+        clamp: true,
+        description: `Max ${max} (default ${LINKEDIN_SENDER_LIMIT_DEFAULTS[key]}).${note ? ` ${note}` : ""}`,
+    });
+}
+export const SENDER_LIMITS_CONTRACT = obj(Object.fromEntries(LINKEDIN_SENDER_LIMIT_KEYS.map((key) => [key, limit(key)])), { description: "Per-account caps for sends and reads. Values above the maximum are clamped server-side." });
+// Merged into the stored window server-side, so a partial edit keeps the rest.
+export const SENDER_WORKING_HOURS_CONTRACT = obj({
+    timezone: str({ description: "IANA zone for hours and daily reset, e.g. Europe/Berlin." }),
+    days: arr(int({ minimum: 1, maximum: 7 }), { description: "ISO weekdays, 1=Mon." }),
+    start: str({ description: "HH:MM, e.g. 09:00." }),
+    end: str({ description: "HH:MM, after start." }),
+}, { description: "When LinkedIn actions may run (default 07:00-22:00 daily); work outside waits. Omitted fields keep their value." });
+export const SENDER_WARMUP_CONTRACT = obj({
+    enabled: bool({ description: "true = start/restart the ramp at day 0; false = disable warm-up (account becomes warm)." }),
+    start_date: nullable(str({
+        description: "ISO date (e.g. 2026-01-31) to anchor the ramp start. A past date credits prior warming and advances the ramp day; a future date holds at day 0 until it arrives. null disables warm-up.",
+    })),
+}, {
+    description: "Warm-up ramp override for this account. Warm-up gradually raises invite + message caps to full over ~2 weeks and is auto-enabled at first connect (pre-existing accounts are treated as already warm). Use { enabled: true } to start/restart the ramp now, { enabled: false } to disable it (account uses its full configured caps), or { start_date } to anchor the ramp to a specific day.",
+});
+export const LINKEDIN_WARMUP_PRESETS = ["conservative", "standard", "fast"];
+export const SENDER_LIMITS_PATCH_CONTRACT = obj({
+    limits: SENDER_LIMITS_CONTRACT,
+    working_hours: SENDER_WORKING_HOURS_CONTRACT,
+    warmup: SENDER_WARMUP_CONTRACT,
+    read_warmup: bool({ description: "Network-capture read ramp: false runs full read budget now; true restarts it from today." }),
+    warmup_preset: enumOf(LINKEDIN_WARMUP_PRESETS, { description: "Warm-up ramp: ~3 weeks, ~2 (default), ~1 for an aged account." }),
+    randomize_daily_caps: bool({ description: "Vary each day's caps a little so volume is not identical daily." }),
+    weekend_full_volume: bool({
+        description: "Send caps halve on Saturday and Sunday in the account's timezone. true keeps full volume; false restores the halving.",
+    }),
+});
+const inferMatchesRoute = true;
+void inferMatchesRoute;
+export const SENDER_LIMITS_SET_OPERATION = {
+    id: "senders.limits.set",
+    route: "/api/cli/senders/{id}/limits",
+    method: "PATCH",
+    contract: SENDER_LIMITS_PATCH_CONTRACT,
+    cli: {
+        path: ["senders", "limits", "set"],
+        summary: "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: { name: "id", description: "Sender account id, connection id, or Unipile account id." },
+    },
+    mcp: {
+        name: "oxygen_senders_limits_set",
+        title: "Oxygen: Set LinkedIn Account Limits",
+        description: "Updates per-account daily limits for sends (invites/messages/InMails) AND reads (relations lists, message history, searches, profile views), working hours, and the warm-up ramp (enable/disable/anchor). Values are clamped to safe maximums to protect the LinkedIn account. LinkedIn actions run only inside working hours.",
+        pack: "deliverability",
+    },
+    mutates: true,
+    spends: false,
+};