@oxygen-agent/cli 1.1010.905 → 1.1010.950

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,
+};

package/node_modules/@oxygen/shared/dist/linkedin-sequences.d.ts

@@ -317,6 +317,17 @@ export type LinkedInSenderLimits = {
     network_backfill_reads_per_day: number;
     network_delta_reads_per_day: number;
 };
+/**
+ * Every LinkedInSenderLimits key, in the order the CLI flags and the MCP
+ * `limits` schema list them (sends, reads, spacing, then the background ingest
+ * budgets). `SENDER_LIMITS_CONTRACT` is generated from this tuple, and a
+ * type-level test pins it to `keyof LinkedInSenderLimits`, so a new limit key
+ * cannot reach the defaults without reaching the CLI and MCP too.
+ */
+export declare const LINKEDIN_SENDER_LIMIT_KEYS: readonly ["invites_per_day", "invites_per_week", "messages_per_day", "inmails_per_day", "inmails_per_month", "profile_views_per_day", "profile_lookups_per_day", "endorsements_per_day", "withdrawals_per_day", "posts_per_day", "follows_per_day", "likes_per_day", "comments_per_day", "total_actions_per_day", "relations_reads_per_day", "messages_reads_per_day", "searches_per_day", "sales_nav_search_results_per_day", "api_reads_per_day", "total_reads_per_day", "min_action_spacing_seconds", "action_spacing_jitter_seconds", "interactive_min_spacing_seconds", "interactive_spacing_jitter_seconds", "interactive_sends_per_hour", "relations_ingest_reads_per_day", "api_ingest_reads_per_day", "messages_ingest_reads_per_day", "network_backfill_reads_per_day", "network_delta_reads_per_day"];
+export type LinkedInSenderLimitKey = (typeof LINKEDIN_SENDER_LIMIT_KEYS)[number];
+type SameKeys<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+export type LinkedInSenderLimitKeysAreComplete = SameKeys<LinkedInSenderLimitKey, keyof LinkedInSenderLimits> extends true ? true : ["LINKEDIN_SENDER_LIMIT_KEYS is missing a LinkedInSenderLimits key"];
 /**
  * Safe defaults for LinkedIn action limits.
  *

package/node_modules/@oxygen/shared/dist/linkedin-sequences.js

@@ -196,6 +196,47 @@ export function truncateLinkedInInviteNote(note, limit) {
     const kept = cut === 0 ? head : head.slice(0, cut);
     return { note: kept.join("").trimEnd(), truncated: true, originalLength };
 }
+/**
+ * Every LinkedInSenderLimits key, in the order the CLI flags and the MCP
+ * `limits` schema list them (sends, reads, spacing, then the background ingest
+ * budgets). `SENDER_LIMITS_CONTRACT` is generated from this tuple, and a
+ * type-level test pins it to `keyof LinkedInSenderLimits`, so a new limit key
+ * cannot reach the defaults without reaching the CLI and MCP too.
+ */
+export const LINKEDIN_SENDER_LIMIT_KEYS = [
+    "invites_per_day",
+    "invites_per_week",
+    "messages_per_day",
+    "inmails_per_day",
+    "inmails_per_month",
+    "profile_views_per_day",
+    "profile_lookups_per_day",
+    "endorsements_per_day",
+    "withdrawals_per_day",
+    "posts_per_day",
+    "follows_per_day",
+    "likes_per_day",
+    "comments_per_day",
+    "total_actions_per_day",
+    "relations_reads_per_day",
+    "messages_reads_per_day",
+    "searches_per_day",
+    "sales_nav_search_results_per_day",
+    "api_reads_per_day",
+    "total_reads_per_day",
+    "min_action_spacing_seconds",
+    "action_spacing_jitter_seconds",
+    "interactive_min_spacing_seconds",
+    "interactive_spacing_jitter_seconds",
+    "interactive_sends_per_hour",
+    "relations_ingest_reads_per_day",
+    "api_ingest_reads_per_day",
+    "messages_ingest_reads_per_day",
+    "network_backfill_reads_per_day",
+    "network_delta_reads_per_day",
+];
+const limitKeysAreComplete = true;
+void limitKeysAreComplete;
 /**
  * Safe defaults for LinkedIn action limits.
  *

package/node_modules/@oxygen/shared/dist/product-briefing-rules.js

@@ -216,10 +216,12 @@ export const OXYGEN_BRIEFING_RULES = [
         probes: [/never block a concrete ask/i],
     },
     {
+        // 2026-09-28: the always-listed dispatch pair replaced the reconnect as the
+        // way a strict host reaches a tool its profile does not list.
         id: "toolset-pack-recovery",
-        rule: "On 'No such tool available', reconnect with the returned `?toolset=<toolset_pack>`; never load a full manifest by default.",
+        rule: "Run a tool the profile does not list through `oxygen_capabilities_read` or `oxygen_capabilities_call`; never load a full manifest by default.",
         home: "mcp",
-        probes: [/\?toolset=<toolset_pack>/],
+        probes: [/oxygen_capabilities_read`? for reads or `?oxygen_capabilities_call/],
     },
     {
         // Both halves of the full-profile rule are load-bearing and they were carried

package/node_modules/@oxygen/shared/dist/table-capacity.d.ts

@@ -38,7 +38,8 @@ export declare const PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST: readonly PlanB
  *   (`storage.<band>.*` in `REPRICING_2026_09_SCHEDULE`): today's envelope until
  *   the effective-date switch, the ratified ladder from it on.
  * - A band awaiting the rows-per-Table capacity test has its ladder workspace
- *   totals and keeps today's rows per Table.
+ *   totals and keeps today's rows per Table, except on the self-hosted dev
+ *   deployment, where the test runs.
  * - Every other band is already at its ladder value.
  */
 export declare function resolveWorkspaceTableCapacity(band: PlanBand, options?: RepricingOptions): WorkspaceTableCapacityLimits;

package/node_modules/@oxygen/shared/dist/table-capacity.js

@@ -49,6 +49,20 @@ export const PLAN_BAND_TABLE_CAPACITY_TARGETS = Object.freeze({
  * had gated both); shipping a band's rows per Table is removing it from this list.
  */
 export const PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST = Object.freeze(["999", "1999"]);
+/**
+ * The capacity test itself runs on the self-hosted dev deployment, which
+ * therefore applies the awaiting bands' full ladder: a 10,000,000-row Table
+ * cannot be measured behind a 3,000,000-row limit. Every other deployment,
+ * production included, keeps the list above. The exact selector is compared
+ * (not `resolveDeployEnv`, which throws on a typo) so a malformed value keeps
+ * the production answer instead of failing a limits read.
+ */
+function awaitsTableRowCapacityTest(band, options) {
+    if (!PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST.includes(band))
+        return false;
+    const env = options.env ?? process.env;
+    return env.OXYGEN_DEPLOY_ENV?.trim().toLowerCase() !== "selfhost-dev";
+}
 const STORAGE_FIELDS = [
     ["tableRowLimit", "table_row_limit"],
     ["workspaceRowLimit", "workspace_row_limit"],
@@ -62,12 +76,13 @@ const STORAGE_FIELDS = [
  *   (`storage.<band>.*` in `REPRICING_2026_09_SCHEDULE`): today's envelope until
  *   the effective-date switch, the ratified ladder from it on.
  * - A band awaiting the rows-per-Table capacity test has its ladder workspace
- *   totals and keeps today's rows per Table.
+ *   totals and keeps today's rows per Table, except on the self-hosted dev
+ *   deployment, where the test runs.
  * - Every other band is already at its ladder value.
  */
 export function resolveWorkspaceTableCapacity(band, options = {}) {
     const target = PLAN_BAND_TABLE_CAPACITY_TARGETS[band];
-    if (PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST.includes(band)) {
+    if (awaitsTableRowCapacityTest(band, options)) {
         return Object.freeze({ ...target, tableRowLimit: WORKSPACE_TABLE_CAPACITY.tableRowLimit });
     }
     const resolved = { ...target };
@@ -80,7 +95,7 @@ export function resolveWorkspaceTableCapacity(band, options = {}) {
     return Object.freeze(resolved);
 }
 export function describeWorkspaceTableCapacityStatus(band, options = {}) {
-    if (PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST.includes(band)) {
+    if (awaitsTableRowCapacityTest(band, options)) {
         return { status: "awaiting_capacity_test", effectiveAt: null, target: PLAN_BAND_TABLE_CAPACITY_TARGETS[band] };
     }
     const state = readRepricingSwitch(options);

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1010.905";
+export declare const OXYGEN_BUILD_VERSION = "1.1010.950";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1010.905";
+export const OXYGEN_BUILD_VERSION = "1.1010.950";

package/node_modules/@oxygen/shared/dist/version.js

@@ -46,4 +46,7 @@ export const OXYGEN_VERSION = OXYGEN_BUILD_VERSION;
 // stop costing a manual step — the lag rule still applies unchanged. The raise
 // also retired both per-route floors, managed inboxes (1.326.2) and the guarded
 // support agent reply (1.747.0): below the global floor they could refuse no one.
+// Since 2026-09-28 the release-preparation step advances this literal to the
+// highest CLI version published on npm for at least 30 days. It never lowers
+// the floor. The source change lands on dev before the next production release.
 export const OXYGEN_MINIMUM_CLI_VERSION = "1.906.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1010.905",
+  "version": "1.1010.950",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",