@oxygen-agent/cli 1.1010.650 → 1.1010.905

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

@@ -13,9 +13,27 @@
 /**
  * Formats that must be held in memory to parse at all — a JSON array has no
  * record boundary to stream from, and XLSX is a zip container. CSV and JSONL
- * stream, so only these two are capped this low.
+ * stream from object storage up to the plan's file limit, so only these two
+ * carry this lower ceiling (raised from 10 MiB by decision F.8, 2026-09-27).
+ *
+ * It also bounds every path that holds a whole file in one request: the inline
+ * multipart import used when object storage is not configured.
  */
 export declare const MAX_BUFFERED_IMPORT_PARSE_BYTES: number;
+/**
+ * A link import (`--url`, `oxygen_tables_import_url`, the wizard's link card)
+ * is downloaded and parsed inside the web request, so it keeps its own small
+ * ceiling. It is not a plan limit: a bigger file is downloaded and imported
+ * with `tables import --file`, which stages it in object storage.
+ */
+export declare const MAX_URL_IMPORT_BYTES: number;
+/**
+ * The largest object one presigned PUT may carry on an S3-compatible store (S3
+ * and Ceph-based stores such as Hetzner Object Storage cap a single PUT at
+ * 5 GiB). A staged import is one PUT, so no plan's import file limit may
+ * exceed it.
+ */
+export declare const IMPORT_OBJECT_SINGLE_PUT_MAX_BYTES: number;
 /**
  * The platform's request-body ceiling — infrastructure, not a plan limit.
  *
@@ -26,3 +44,9 @@ export declare const MAX_BUFFERED_IMPORT_PARSE_BYTES: number;
 export declare const VERCEL_REQUEST_BODY_LIMIT_BYTES: number;
 /** True for the formats that cannot stream and so carry the buffered ceiling. */
 export declare function isBufferedOnlyImportFormat(format: string): boolean;
+/**
+ * The refusal every surface gives a JSON or XLSX file over the buffered
+ * ceiling. It names the ceiling and the two formats that take a larger file,
+ * so the reader knows the fix is a format change, not a plan change.
+ */
+export declare function bufferedImportTooLargeMessage(format: string, fileBytes?: number | null): string;

package/node_modules/@oxygen/shared/dist/import-limits.js

@@ -10,12 +10,31 @@
  * constants live here alone, and both of those modules re-export them, keeping
  * one definition rather than a copy that drifts.
  */
+const MIB = 1024 * 1024;
 /**
  * Formats that must be held in memory to parse at all — a JSON array has no
  * record boundary to stream from, and XLSX is a zip container. CSV and JSONL
- * stream, so only these two are capped this low.
+ * stream from object storage up to the plan's file limit, so only these two
+ * carry this lower ceiling (raised from 10 MiB by decision F.8, 2026-09-27).
+ *
+ * It also bounds every path that holds a whole file in one request: the inline
+ * multipart import used when object storage is not configured.
+ */
+export const MAX_BUFFERED_IMPORT_PARSE_BYTES = 100 * MIB;
+/**
+ * A link import (`--url`, `oxygen_tables_import_url`, the wizard's link card)
+ * is downloaded and parsed inside the web request, so it keeps its own small
+ * ceiling. It is not a plan limit: a bigger file is downloaded and imported
+ * with `tables import --file`, which stages it in object storage.
+ */
+export const MAX_URL_IMPORT_BYTES = 10 * MIB;
+/**
+ * The largest object one presigned PUT may carry on an S3-compatible store (S3
+ * and Ceph-based stores such as Hetzner Object Storage cap a single PUT at
+ * 5 GiB). A staged import is one PUT, so no plan's import file limit may
+ * exceed it.
  */
-export const MAX_BUFFERED_IMPORT_PARSE_BYTES = 10 * 1024 * 1024;
+export const IMPORT_OBJECT_SINGLE_PUT_MAX_BYTES = 5 * 1024 * MIB;
 /**
  * The platform's request-body ceiling — infrastructure, not a plan limit.
  *
@@ -28,3 +47,17 @@ export const VERCEL_REQUEST_BODY_LIMIT_BYTES = 4 * 1024 * 1024;
 export function isBufferedOnlyImportFormat(format) {
     return format === "json" || format === "xlsx";
 }
+/**
+ * The refusal every surface gives a JSON or XLSX file over the buffered
+ * ceiling. It names the ceiling and the two formats that take a larger file,
+ * so the reader knows the fix is a format change, not a plan change.
+ */
+export function bufferedImportTooLargeMessage(format, fileBytes) {
+    const label = format.toUpperCase();
+    const size = typeof fileBytes === "number" ? ` This one is ${formatImportMib(fileBytes)}.` : "";
+    return `${label} files are read whole, so they are capped at ${formatImportMib(MAX_BUFFERED_IMPORT_PARSE_BYTES)}.${size} Save it as CSV or JSONL, which import up to your plan's file-size limit.`;
+}
+function formatImportMib(bytes) {
+    const mib = bytes / MIB;
+    return `${mib >= 10 ? Math.round(mib).toLocaleString("en-US") : mib.toFixed(1)} MiB`;
+}

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { MANAGED_INBOX_MINIMUM_CLI_VERSION, OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION, SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION, } from "./version.js";
+export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION, } from "./version.js";
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export { WORKFLOW_STATUS_CHANGE_METADATA_KEY, type WorkflowStatusChange, type WorkflowStatusChangeActor, type WorkflowStatusChangeSource, describeWorkflowStatusChange, formatWorkflowStatusChangeTimestamp, parseWorkflowStatusChange, readWorkflowStatusChange, } from "./workflow-status-change.js";
 export * from "./billing.js";
@@ -10,6 +10,7 @@ export * from "./capability-discovery.js";
 export * from "./user-capability-routing.js";
 export * from "./plan-capabilities.js";
 export * from "./plan-limits.js";
+export * from "./plan-band.js";
 export * from "./sending-seats.js";
 export * from "./sending-seat-capacity.js";
 export * from "./plain-support-events.js";
@@ -37,7 +38,7 @@ export * from "./credit-guidance.js";
 export * from "./deploy-env.js";
 export * from "./directory.js";
 export * from "./email-dsn.js";
-export * from "./email-warmup-readiness.js";
+export * from "./email-hard-bounce.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./error-redaction.js";
@@ -110,27 +111,7 @@ export * from "./workspace-event-catalog.js";
 export * from "./notetaker-events.js";
 export * from "./workspace-agents.js";
 export declare const MAX_ROW_LOOP_WRITE_ROWS = 500;
-export type SemanticVersion = {
-    major: number;
-    minor: number;
-    patch: number;
-};
-/**
- * Parse a three-segment semantic version (e.g. `1.142.17`). Pre-release and
- * build metadata suffixes (`-rc.1`, `+build`) are tolerated but ignored.
- * Returns `null` when the input is not a parseable `major.minor.patch` string.
- */
-export declare function parseSemver(version: string): SemanticVersion | null;
-/**
- * Compare two semantic versions. Returns -1 when `a < b`, 1 when `a > b`, and
- * 0 when they are equal. Unparseable inputs compare as equal (0) so callers
- * fail open rather than misordering garbage.
- */
-export declare function compareSemver(a: string, b: string): -1 | 0 | 1;
-/** True when `a` is a strictly greater semantic version than `b`. */
-export declare function isVersionGreater(a: string, b: string): boolean;
-/** True when `a` is a strictly lesser semantic version than `b`. */
-export declare function isVersionLess(a: string, b: string): boolean;
+export * from "./semver.js";
 export * from "./ugc.js";
 export * from "./ugc-amplification-identity.js";
 export * from "./knowledge-repository.js";

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

@@ -1,4 +1,4 @@
-export { MANAGED_INBOX_MINIMUM_CLI_VERSION, OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION, SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION, } from "./version.js";
+export { OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_VERSION, } from "./version.js";
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export { WORKFLOW_STATUS_CHANGE_METADATA_KEY, describeWorkflowStatusChange, formatWorkflowStatusChangeTimestamp, parseWorkflowStatusChange, readWorkflowStatusChange, } from "./workflow-status-change.js";
 export * from "./billing.js";
@@ -10,6 +10,7 @@ export * from "./capability-discovery.js";
 export * from "./user-capability-routing.js";
 export * from "./plan-capabilities.js";
 export * from "./plan-limits.js";
+export * from "./plan-band.js";
 export * from "./sending-seats.js";
 export * from "./sending-seat-capacity.js";
 export * from "./plain-support-events.js";
@@ -37,7 +38,7 @@ export * from "./credit-guidance.js";
 export * from "./deploy-env.js";
 export * from "./directory.js";
 export * from "./email-dsn.js";
-export * from "./email-warmup-readiness.js";
+export * from "./email-hard-bounce.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./error-redaction.js";
@@ -126,47 +127,7 @@ export * from "./workspace-agents.js";
 // the COPY-based bulk engine. Tenant-db enforces this and the CLI/API row caps
 // reference it so they never advertise a batch the row-loop will reject.
 export const MAX_ROW_LOOP_WRITE_ROWS = 500;
-/**
- * Parse a three-segment semantic version (e.g. `1.142.17`). Pre-release and
- * build metadata suffixes (`-rc.1`, `+build`) are tolerated but ignored.
- * Returns `null` when the input is not a parseable `major.minor.patch` string.
- */
-export function parseSemver(version) {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version);
-    if (!match)
-        return null;
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-    };
-}
-/**
- * Compare two semantic versions. Returns -1 when `a < b`, 1 when `a > b`, and
- * 0 when they are equal. Unparseable inputs compare as equal (0) so callers
- * fail open rather than misordering garbage.
- */
-export function compareSemver(a, b) {
-    const left = parseSemver(a);
-    const right = parseSemver(b);
-    if (!left || !right)
-        return 0;
-    for (const key of ["major", "minor", "patch"]) {
-        if (left[key] > right[key])
-            return 1;
-        if (left[key] < right[key])
-            return -1;
-    }
-    return 0;
-}
-/** True when `a` is a strictly greater semantic version than `b`. */
-export function isVersionGreater(a, b) {
-    return compareSemver(a, b) > 0;
-}
-/** True when `a` is a strictly lesser semantic version than `b`. */
-export function isVersionLess(a, b) {
-    return compareSemver(a, b) < 0;
-}
+export * from "./semver.js";
 export * from "./ugc.js";
 export * from "./ugc-amplification-identity.js";
 export * from "./knowledge-repository.js";

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

@@ -247,4 +247,118 @@ export declare function truncateLinkedInInviteNote(note: string, limit: number):
     truncated: boolean;
     originalLength: number;
 };
+export type LinkedInSenderLimits = {
+    invites_per_day: number;
+    invites_per_week: number;
+    messages_per_day: number;
+    inmails_per_day: number;
+    /**
+     * InMails in a rolling 30 days (today and the 29 before it, in the account's
+     * day). Checked under the same sender row lock as the weekly invite cap, so
+     * concurrent claims cannot both pass a stale sum.
+     */
+    inmails_per_month: number;
+    profile_views_per_day: number;
+    /**
+     * Invisible profile and company lookups (`users_get` with notify:false,
+     * `company_get`). The member is never notified, so these are reads, but
+     * Unipile relays LinkedIn's ~100 profile retrievals a day for them.
+     */
+    profile_lookups_per_day: number;
+    /** Skill endorsements. Used to share the follow cap. */
+    endorsements_per_day: number;
+    /**
+     * Sent-invitation withdrawals (the withdraw action itself, not the reads of
+     * the sent-invite list). LinkedIn blocks re-inviting a withdrawn member for
+     * three weeks; see the re-invite guard.
+     */
+    withdrawals_per_day: number;
+    /** Posts to the member's own feed, from every caller. Timing-exempt, never uncapped. */
+    posts_per_day: number;
+    follows_per_day: number;
+    likes_per_day: number;
+    comments_per_day: number;
+    total_actions_per_day: number;
+    min_action_spacing_seconds: number;
+    action_spacing_jitter_seconds: number;
+    interactive_min_spacing_seconds: number;
+    interactive_spacing_jitter_seconds: number;
+    /**
+     * Backstop on the interactive lane: how many human-paced sends an account may
+     * make in a rolling hour.
+     *
+     * Mostly redundant with messages_per_day (whose maximum is 40), and that is
+     * deliberate — it bounds BURST SHAPE rather than volume. Volume is already
+     * capped; this stops the whole daily allowance being spent in four minutes if
+     * the interactive classification is ever wrong, which is the one failure mode
+     * the daily cap cannot see.
+     */
+    interactive_sends_per_hour: number;
+    relations_reads_per_day: number;
+    messages_reads_per_day: number;
+    searches_per_day: number;
+    sales_nav_search_results_per_day: number;
+    api_reads_per_day: number;
+    total_reads_per_day: number;
+    relations_ingest_reads_per_day: number;
+    api_ingest_reads_per_day: number;
+    messages_ingest_reads_per_day: number;
+    /**
+     * Network-capture read budgets: the two-phase allowance for enumerating an
+     * account's OWN 1st-degree connections and followers into a workspace table.
+     *
+     * Two keys, not one, because Unipile's own guidance for the relations list is
+     * explicitly two-phase: a heavier initial sync, then "retrieving the first page
+     * only a few times a day with randomly spaced intervals". One flat number would
+     * either make the first walk take weeks or leave a steady-state drip reading far
+     * more than it needs forever. Both still meter as `relations_ingest_read` against
+     * one shared daily counter, so an account cannot spend both budgets at once.
+     */
+    network_backfill_reads_per_day: number;
+    network_delta_reads_per_day: number;
+};
+/**
+ * Safe defaults for LinkedIn action limits.
+ *
+ * PROVENANCE, because these numbers get copied and should not be laundered into
+ * authority they do not have:
+ *
+ * - The 20-25/day connection-request range and the 40/day message posture come
+ *   from third-party operator playbooks describing HeyReach-style outreach, NOT
+ *   from HeyReach. HeyReach's own sending-limits article publishes no numbers at
+ *   all — it only says you configure per-action daily limits and that it "will
+ *   always try to reach those limits". An earlier version of this comment cited
+ *   HeyReach directly; that attribution was wrong.
+ * - The READ budgets (relations/api/messages, ingest and network capture) are
+ *   anchored on Unipile's documented per-route recommendations, which relay
+ *   LinkedIn's own limits: ~80-100 invitations/day, ~100 profile retrievals/day,
+ *   and 100/day per account for "all other routes" — the bucket users_relations
+ *   and users_followers fall into. Unipile enforces none of it; cadence is ours
+ *   to choose, and exceeding returns 429/500 and can disconnect the account.
+ *   See developer.unipile.com/docs/provider-limits-and-restrictions.
+ *
+ * The weekly invite and 200-total-action guards stay enforced independently.
+ * Users can lower limits per account, but never raise them above
+ * LINKEDIN_SENDER_LIMIT_MAXIMUMS.
+ */
+export declare const LINKEDIN_SENDER_LIMIT_DEFAULTS: LinkedInSenderLimits;
+export declare const LINKEDIN_SENDER_LIMIT_MAXIMUMS: LinkedInSenderLimits;
+/**
+ * LinkedIn refuses a new invitation to a member whose earlier invitation from
+ * the same account was withdrawn, for about three weeks. OXYGEN records every
+ * withdrawal it makes and refuses the re-invite itself for this long, so the
+ * refusal is ours (with a reset time) instead of a provider 422.
+ */
+export declare const LINKEDIN_REINVITE_COOLDOWN_DAYS = 21;
+/**
+ * Whether a refused invitation is LinkedIn's re-invite cooldown: Unipile answers
+ * HTTP 422 with the `cannot_resend_yet` error type. Anchored on the type, with
+ * the message as a fallback for the provider shapes that carry the type only in
+ * the sentence. Pure and total.
+ */
+export declare function isLinkedInReinviteCooldownRefusal(input: {
+    status: number | null;
+    providerType: string | null;
+    providerMessage: string | null;
+}): boolean;
 export {};

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

@@ -196,3 +196,153 @@ export function truncateLinkedInInviteNote(note, limit) {
     const kept = cut === 0 ? head : head.slice(0, cut);
     return { note: kept.join("").trimEnd(), truncated: true, originalLength };
 }
+/**
+ * Safe defaults for LinkedIn action limits.
+ *
+ * PROVENANCE, because these numbers get copied and should not be laundered into
+ * authority they do not have:
+ *
+ * - The 20-25/day connection-request range and the 40/day message posture come
+ *   from third-party operator playbooks describing HeyReach-style outreach, NOT
+ *   from HeyReach. HeyReach's own sending-limits article publishes no numbers at
+ *   all — it only says you configure per-action daily limits and that it "will
+ *   always try to reach those limits". An earlier version of this comment cited
+ *   HeyReach directly; that attribution was wrong.
+ * - The READ budgets (relations/api/messages, ingest and network capture) are
+ *   anchored on Unipile's documented per-route recommendations, which relay
+ *   LinkedIn's own limits: ~80-100 invitations/day, ~100 profile retrievals/day,
+ *   and 100/day per account for "all other routes" — the bucket users_relations
+ *   and users_followers fall into. Unipile enforces none of it; cadence is ours
+ *   to choose, and exceeding returns 429/500 and can disconnect the account.
+ *   See developer.unipile.com/docs/provider-limits-and-restrictions.
+ *
+ * The weekly invite and 200-total-action guards stay enforced independently.
+ * Users can lower limits per account, but never raise them above
+ * LINKEDIN_SENDER_LIMIT_MAXIMUMS.
+ */
+export const LINKEDIN_SENDER_LIMIT_DEFAULTS = {
+    invites_per_day: 20,
+    invites_per_week: 100,
+    messages_per_day: 40,
+    inmails_per_day: 10,
+    // Competitors cap open-profile InMail near 800/month; 400 leaves headroom.
+    inmails_per_month: 400,
+    profile_views_per_day: 50,
+    profile_lookups_per_day: 80,
+    endorsements_per_day: 5,
+    withdrawals_per_day: 10,
+    // Matches the order of magnitude of a busy human poster; the publishing
+    // scheduler's own 25-per-24h ceiling stays a second guard.
+    posts_per_day: 10,
+    follows_per_day: 20,
+    likes_per_day: 20,
+    comments_per_day: 5,
+    total_actions_per_day: 150,
+    min_action_spacing_seconds: 300,
+    action_spacing_jitter_seconds: 300,
+    // 1s, no jitter: a person working their own inbox should never meet this gate.
+    // It exists only to stop a genuine burst — a stuck key, a runaway client — from
+    // firing an account's whole hour in a second, and to keep the per-account row
+    // lock (and with it the hourly counter) in play. Jitter is 0 deliberately: the
+    // variance in human sending is the human, and adding 0-5s on top only makes the
+    // product feel slow. Non-zero spacing is still required — see the fast-path note
+    // in reserveLinkedInSenderActionSlot.
+    interactive_min_spacing_seconds: 1,
+    interactive_spacing_jitter_seconds: 0,
+    // The primary bound on human sending now that it no longer claims the daily
+    // message cap. 200/hour is ~3/minute sustained: never felt by someone answering
+    // their inbox, and still a hard ceiling if the interactive classification is
+    // ever wrong.
+    interactive_sends_per_hour: 200,
+    // Conservative read budgets: roughly human-speed usage. Bulk scraping
+    // (full contact-list exports, whole-inbox pulls, search harvesting) is
+    // impossible by default — the pattern that gets accounts banned.
+    relations_reads_per_day: 20,
+    messages_reads_per_day: 200,
+    searches_per_day: 20,
+    sales_nav_search_results_per_day: 1000,
+    api_reads_per_day: 200,
+    total_reads_per_day: 1000,
+    // Conservative ingestion drips: a large network/history import spreads over
+    // many days rather than bursting, and stays well within total_reads_per_day.
+    // History backfill is the slowest drip (full thread walks are the most
+    // ban-sensitive bulk read), so its default is the tightest of the three.
+    relations_ingest_reads_per_day: 15,
+    api_ingest_reads_per_day: 20,
+    messages_ingest_reads_per_day: 10,
+    // Network capture, phase 1: 40% of Unipile's documented ~100/day recommendation
+    // for these routes. At 50 members a page that is ~2,000 people/day, so a typical
+    // network lands in days rather than weeks while leaving most of the account's
+    // daily read headroom unused.
+    network_backfill_reads_per_day: 40,
+    // Phase 2, once the walk is exhausted: Unipile's "first page a few times a day".
+    // New connections and followers arrive at the TOP of both listings, so a handful
+    // of first-page reads catches them all; the drip re-walks deeper only if it finds
+    // a full page of new people.
+    network_delta_reads_per_day: 4,
+};
+export const LINKEDIN_SENDER_LIMIT_MAXIMUMS = {
+    invites_per_day: 30,
+    invites_per_week: 150,
+    messages_per_day: 40,
+    // Lowered 40 → 25 and 150 → 100 (2026-09-26, founder decision "add missing
+    // caps + tighten"): operator playbooks put InMail at ≤25/day and profile views
+    // at 50-100. Stored overrides above these clamp at read time.
+    inmails_per_day: 25,
+    inmails_per_month: 800,
+    profile_views_per_day: 100,
+    // Unipile relays ~100 profile retrievals a day as LinkedIn's own ceiling.
+    profile_lookups_per_day: 100,
+    endorsements_per_day: 10,
+    withdrawals_per_day: 20,
+    posts_per_day: 25,
+    follows_per_day: 50,
+    likes_per_day: 50,
+    // Lowered 50 → 20 (2026-09-25): public comments are the most visible automated
+    // signal an account emits, and the one LinkedIn's inauthentic-engagement
+    // enforcement keys on. Stored overrides above this clamp at read time.
+    comments_per_day: 20,
+    total_actions_per_day: 200,
+    min_action_spacing_seconds: 3600,
+    action_spacing_jitter_seconds: 1800,
+    interactive_min_spacing_seconds: 3600,
+    interactive_spacing_jitter_seconds: 1800,
+    // Lowered 1000 → 300 (2026-09-25): 5/minute sustained is still far above
+    // anyone answering their own inbox, and bounds a misclassified bulk send.
+    interactive_sends_per_hour: 300,
+    relations_reads_per_day: 100,
+    messages_reads_per_day: 600,
+    searches_per_day: 100,
+    sales_nav_search_results_per_day: 1000,
+    api_reads_per_day: 1000,
+    total_reads_per_day: 2000,
+    relations_ingest_reads_per_day: 100,
+    api_ingest_reads_per_day: 200,
+    messages_ingest_reads_per_day: 200,
+    // 100/day is Unipile's own documented recommendation for "all other routes",
+    // which is the bucket users_relations and users_followers fall into. Our hard
+    // maximum is exactly the vendor's number and must not be raised above it.
+    network_backfill_reads_per_day: 100,
+    network_delta_reads_per_day: 20,
+};
+// ===== Re-invite cooldown =====
+/**
+ * LinkedIn refuses a new invitation to a member whose earlier invitation from
+ * the same account was withdrawn, for about three weeks. OXYGEN records every
+ * withdrawal it makes and refuses the re-invite itself for this long, so the
+ * refusal is ours (with a reset time) instead of a provider 422.
+ */
+export const LINKEDIN_REINVITE_COOLDOWN_DAYS = 21;
+/**
+ * Whether a refused invitation is LinkedIn's re-invite cooldown: Unipile answers
+ * HTTP 422 with the `cannot_resend_yet` error type. Anchored on the type, with
+ * the message as a fallback for the provider shapes that carry the type only in
+ * the sentence. Pure and total.
+ */
+export function isLinkedInReinviteCooldownRefusal(input) {
+    if (input.status !== 422)
+        return false;
+    if (typeof input.providerType === "string" && /(?:^|\/)cannot_resend_yet$/u.test(input.providerType.trim()))
+        return true;
+    return typeof input.providerMessage === "string" && /\bcannot_resend_yet\b/u.test(input.providerMessage);
+}

package/node_modules/@oxygen/shared/dist/object-storage.d.ts

@@ -62,6 +62,15 @@ export type PresignedImportUpload = {
     expiresInSeconds: number;
 };
 export type PresignedPublishingMediaUpload = PresignedImportUpload;
+/**
+ * Presign the one PUT that stages an import file under `imports/<org>/`.
+ *
+ * Import staging is deliberately NOT a workspace file (`workspace-file-storage`):
+ * it is transient input the worker streams once and deletes, so neither the
+ * 100 MiB per-file nor the 1 GiB retained-files ceiling of that store applies.
+ * Its ceiling is the caller's plan import limit, checked by the route before it
+ * asks, plus the single-PUT maximum below, which no plan exceeds.
+ */
 export declare function presignImportUpload(input: {
     organizationId: string;
     fileName?: string | null;

package/node_modules/@oxygen/shared/dist/object-storage.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { OxygenError } from "./cli-result.js";
+import { IMPORT_OBJECT_SINGLE_PUT_MAX_BYTES } from "./import-limits.js";
 // S3-compatible object storage for large CSV/file imports. The CLI uploads the
 // raw file straight to the bucket via a presigned PUT URL (bypassing Vercel's
 // ~4.5MB request-body limit), then the Fly worker downloads it and COPY-loads
@@ -141,7 +142,23 @@ export function isCopilotAttachmentObjectKeyForOrganization(key, organizationId)
 export function isPublishingMediaObjectKeyForOrganization(key, organizationId) {
     return key.startsWith(`publishing-media/${organizationId}/`);
 }
+/**
+ * Presign the one PUT that stages an import file under `imports/<org>/`.
+ *
+ * Import staging is deliberately NOT a workspace file (`workspace-file-storage`):
+ * it is transient input the worker streams once and deletes, so neither the
+ * 100 MiB per-file nor the 1 GiB retained-files ceiling of that store applies.
+ * Its ceiling is the caller's plan import limit, checked by the route before it
+ * asks, plus the single-PUT maximum below, which no plan exceeds.
+ */
 export async function presignImportUpload(input) {
+    if (!Number.isSafeInteger(input.contentLength) || input.contentLength < 1
+        || input.contentLength > IMPORT_OBJECT_SINGLE_PUT_MAX_BYTES) {
+        throw new OxygenError("request_too_large", "Import file is too large to stage in one upload.", {
+            details: { file_bytes: input.contentLength, max_file_bytes: IMPORT_OBJECT_SINGLE_PUT_MAX_BYTES },
+            exitCode: 1,
+        });
+    }
     const { client, config } = resolveClient();
     const storageKey = buildImportObjectKey({
         organizationId: input.organizationId,

package/node_modules/@oxygen/shared/dist/operational-telemetry.d.ts

@@ -21,4 +21,45 @@ export declare function operationalSpanSnapshot<T extends {
     instrumentationScope?: AttributeContainer;
     spanContext(): unknown;
 }>(span: T): T;
+type ExportResource = {
+    attributes: Record<string, unknown>;
+};
+/**
+ * Maps the SDK resource onto the resource the collector destination exports,
+ * without touching the one every other destination reads. `rewrite` receives the
+ * SDK resource's attributes and returns the collector's; the result is
+ * sanitized once and memoized per source resource, so every span in a batch
+ * keeps sharing one resource object and the OTLP encoder still groups them into
+ * a single ResourceSpans entry.
+ *
+ * A resource whose async detectors are still pending (`asyncAttributesPending`)
+ * is mapped but not memoized, so attributes that settle later are picked up on
+ * a later export instead of an incomplete overlay being kept for the process.
+ */
+export declare function collectorResourceMapper(rewrite: (attributes: Record<string, unknown>) => Record<string, unknown>): (resource: MappableResource | undefined) => ExportResource;
+type MappableResource = {
+    attributes?: Record<string, unknown>;
+    asyncAttributesPending?: boolean;
+};
+type SnapshotSpan = Parameters<typeof operationalSpanSnapshot>[0];
+/**
+ * The collector's per-span export transform: the sanitized snapshot, with the
+ * resource swapped for the collector's when a mapper is given. Without one it
+ * is exactly `operationalSpanSnapshot`.
+ */
+export declare function collectorSpanSnapshot(resourceFor?: (resource: MappableResource | undefined) => ExportResource): <T extends SnapshotSpan>(span: T) => T;
+type MetricExporterLike = {
+    export(metrics: unknown, resultCallback: (result: {
+        code: number;
+        error?: Error | undefined;
+    }) => void): void;
+    shutdown(): Promise<void>;
+};
+/**
+ * Wraps a metric exporter so each ResourceMetrics batch carries the collector's
+ * resource. The reader-facing methods (temporality/aggregation selection,
+ * forceFlush) are forwarded only when the inner exporter has them, so the
+ * PeriodicExportingMetricReader sees exactly what it would have unwrapped.
+ */
+export declare function withCollectorMetricResource<E extends MetricExporterLike>(inner: E, resourceFor: (resource: MappableResource | undefined) => ExportResource): E;
 export {};

package/node_modules/@oxygen/shared/dist/operational-telemetry.js

@@ -1,4 +1,5 @@
 import { normalizeTelemetryAttributes, redactSecretsInString } from "./redaction.js";
+import { forwardExporterMethods } from "./telemetry-export-observer.js";
 // Namespaced semantic-convention fields evade the generic exact-key log policy.
 // Numeric usage remains operational data, subject to the shared secret policy.
 const PAYLOAD_KEY = /(?:^|[._-])(?:prompts?|completions?|inputs?|outputs?|payloads?|rows?|messages?|content|body|customer_data)(?:$|[._-])|^(?:request|response)$/i;
@@ -71,3 +72,57 @@ function stripOperationalUrl(value) {
         return value.split(/[?#]/, 1)[0] ?? "";
     }
 }
+/**
+ * Maps the SDK resource onto the resource the collector destination exports,
+ * without touching the one every other destination reads. `rewrite` receives the
+ * SDK resource's attributes and returns the collector's; the result is
+ * sanitized once and memoized per source resource, so every span in a batch
+ * keeps sharing one resource object and the OTLP encoder still groups them into
+ * a single ResourceSpans entry.
+ *
+ * A resource whose async detectors are still pending (`asyncAttributesPending`)
+ * is mapped but not memoized, so attributes that settle later are picked up on
+ * a later export instead of an incomplete overlay being kept for the process.
+ */
+export function collectorResourceMapper(rewrite) {
+    const cache = new WeakMap();
+    let withoutSource;
+    return (resource) => {
+        if (!resource)
+            return withoutSource ??= { attributes: operationalAttributes(rewrite({})) };
+        const cached = cache.get(resource);
+        if (cached)
+            return cached;
+        const mapped = { attributes: operationalAttributes(rewrite(resource.attributes ?? {})) };
+        if (!resource.asyncAttributesPending)
+            cache.set(resource, mapped);
+        return mapped;
+    };
+}
+/**
+ * The collector's per-span export transform: the sanitized snapshot, with the
+ * resource swapped for the collector's when a mapper is given. Without one it
+ * is exactly `operationalSpanSnapshot`.
+ */
+export function collectorSpanSnapshot(resourceFor) {
+    if (!resourceFor)
+        return (span) => operationalSpanSnapshot(span);
+    return (span) => ({ ...operationalSpanSnapshot(span), resource: resourceFor(span.resource) });
+}
+/**
+ * Wraps a metric exporter so each ResourceMetrics batch carries the collector's
+ * resource. The reader-facing methods (temporality/aggregation selection,
+ * forceFlush) are forwarded only when the inner exporter has them, so the
+ * PeriodicExportingMetricReader sees exactly what it would have unwrapped.
+ */
+export function withCollectorMetricResource(inner, resourceFor) {
+    const wrapped = {
+        export(metrics, resultCallback) {
+            const batch = metrics;
+            inner.export({ ...batch, resource: resourceFor(batch.resource) }, resultCallback);
+        },
+        shutdown: () => inner.shutdown(),
+    };
+    forwardExporterMethods(inner, wrapped);
+    return wrapped;
+}