@oxygen-agent/cli 1.696.2 → 1.717.1

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

@@ -34,6 +34,8 @@ export type MailboxImportValidationSummary = {
 };
 export type MailboxOAuthProviderReviewPlan = {
     mailboxes: number;
+    authorization_mode: "individual" | "tenant";
+    batch_size: number;
     batches: number;
     batch_sizes: number[];
 };
@@ -42,7 +44,9 @@ export type MailboxOAuthReviewPlan = {
     scope: "validated_addresses";
     directory_discovery: false;
     existing_grants_checked: false;
+    /** Backward-compatible individual OAuth review size. */
     batch_size: number;
+    tenant_batch_size: number;
     total_batches: number;
     providers: {
         google: MailboxOAuthProviderReviewPlan;
@@ -75,10 +79,12 @@ export declare function summarizeMailboxImportValidation(mailboxes: readonly Nor
     sourceProvider: string | null;
 }): MailboxImportValidationSummary;
 /**
- * Build the deterministic, provider-specific review queue for exact-account
- * OAuth. This is safe during local file validation: it uses only normalized
- * provider counts, performs no directory discovery, and does not claim to know
- * whether a workspace already holds a usable grant for an address.
+ * Build the deterministic, provider-specific review queue for exact mailbox
+ * authorization. This is safe during local file validation: it uses only
+ * normalized provider counts, performs no directory discovery, and does not
+ * claim to know whether a workspace already holds a usable grant for an address.
+ * Multi-mailbox Microsoft imports recommend one tenant-admin batch; a single
+ * Microsoft mailbox and all Google mailboxes retain individual OAuth.
  */
 export declare function planMailboxOAuthReviews(mailboxes: readonly Pick<NormalizedMailboxImportRow, "provider">[]): MailboxOAuthReviewPlan;
 export declare function normalizeMailboxImportVendor(raw: string | null | undefined, from: string | null | undefined): string | null;

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

@@ -208,35 +208,43 @@ export function summarizeMailboxImportValidation(mailboxes, input) {
     };
 }
 /**
- * Build the deterministic, provider-specific review queue for exact-account
- * OAuth. This is safe during local file validation: it uses only normalized
- * provider counts, performs no directory discovery, and does not claim to know
- * whether a workspace already holds a usable grant for an address.
+ * Build the deterministic, provider-specific review queue for exact mailbox
+ * authorization. This is safe during local file validation: it uses only
+ * normalized provider counts, performs no directory discovery, and does not
+ * claim to know whether a workspace already holds a usable grant for an address.
+ * Multi-mailbox Microsoft imports recommend one tenant-admin batch; a single
+ * Microsoft mailbox and all Google mailboxes retain individual OAuth.
  */
 export function planMailboxOAuthReviews(mailboxes) {
     const counts = { google: 0, microsoft: 0 };
     for (const mailbox of mailboxes)
         counts[mailbox.provider] += 1;
-    const google = planProviderOAuthReviews(counts.google);
-    const microsoft = planProviderOAuthReviews(counts.microsoft);
+    const google = planProviderOAuthReviews(counts.google, MAILBOX_OAUTH_REVIEW_BATCH_SIZE, "individual");
+    const microsoftMode = counts.microsoft > 1 ? "tenant" : "individual";
+    const microsoft = planProviderOAuthReviews(counts.microsoft, microsoftMode === "tenant"
+        ? MAILBOX_IMPORT_ROW_LIMIT
+        : MAILBOX_OAUTH_REVIEW_BATCH_SIZE, microsoftMode);
     return {
         authorization: "exact_account_oauth",
         scope: "validated_addresses",
         directory_discovery: false,
         existing_grants_checked: false,
         batch_size: MAILBOX_OAUTH_REVIEW_BATCH_SIZE,
+        tenant_batch_size: MAILBOX_IMPORT_ROW_LIMIT,
         total_batches: google.batches + microsoft.batches,
         providers: { google, microsoft },
     };
 }
-function planProviderOAuthReviews(mailboxes) {
-    const fullBatches = Math.floor(mailboxes / MAILBOX_OAUTH_REVIEW_BATCH_SIZE);
-    const remainder = mailboxes % MAILBOX_OAUTH_REVIEW_BATCH_SIZE;
-    const batchSizes = Array.from({ length: fullBatches }, () => MAILBOX_OAUTH_REVIEW_BATCH_SIZE);
+function planProviderOAuthReviews(mailboxes, batchSize, authorizationMode) {
+    const fullBatches = Math.floor(mailboxes / batchSize);
+    const remainder = mailboxes % batchSize;
+    const batchSizes = Array.from({ length: fullBatches }, () => batchSize);
     if (remainder > 0)
         batchSizes.push(remainder);
     return {
         mailboxes,
+        authorization_mode: authorizationMode,
+        batch_size: batchSize,
         batches: batchSizes.length,
         batch_sizes: batchSizes,
     };

package/node_modules/@oxygen/shared/dist/member-columns.d.ts

@@ -0,0 +1,64 @@
+/** Canonical semantic for a member-reference column on any object. */
+export declare const MEMBER_COLUMN_SEMANTIC = "member";
+export declare function isMemberColumnSemantic(semanticType: string | null | undefined): boolean;
+/**
+ * One workspace member, as every surface needs them: the email is the stored
+ * cell value and the join key, `userId` is the control-db id for anything that
+ * has to talk to the control plane, and name/image are display only.
+ *
+ * `isActive` false means the row resolved out of a historical membership that
+ * no longer holds — the cell still renders the person rather than going blank,
+ * because "Sarah owned this before she left" is information, not an error.
+ */
+export type WorkspaceMemberRef = {
+    email: string;
+    userId: string | null;
+    name: string | null;
+    imageUrl: string | null;
+    isActive: boolean;
+};
+/** Email (lowercased) → member. The shape the API layer puts on an envelope. */
+export type MemberDirectory = Record<string, WorkspaceMemberRef>;
+/**
+ * Canonical form of a member cell value: a lowercased, trimmed email.
+ *
+ * Anything that is not an email is preserved verbatim (trimmed) rather than
+ * rejected — existing `owner` columns are free text and hold real names typed
+ * by real founders. Losing "Philipp" on the way to a typed column would be a
+ * silent data deletion; carrying it as an unresolved value is honest and lets
+ * the owner picker repair it one click at a time.
+ */
+export declare function normalizeMemberCellValue(raw: unknown): string | null;
+/** Build the lookup the render + validation paths use, keyed on lowercased email. */
+export declare function buildMemberDirectory(members: readonly WorkspaceMemberRef[]): MemberDirectory;
+export type ResolvedMemberCell = {
+    /** The canonical stored value, or null for an empty cell. */
+    value: string | null;
+    /** The directory hit, when there is one. */
+    member: WorkspaceMemberRef | null;
+    /**
+     * A non-empty value that no directory entry matched: a legacy free-text
+     * owner, a member who left, or a changed address. Renders as a plain grey
+     * chip so it reads as "unrecognised", never as a normal member.
+     */
+    unresolved: boolean;
+};
+/**
+ * Resolve one stored cell value against a directory. Pure, total, and never
+ * throws: a missing directory (the API layer could not reach the control plane)
+ * degrades every cell to `unresolved`, which shows the raw value instead of
+ * blanking a column — the same posture the activity timeline takes when link
+ * decoration fails.
+ */
+export declare function resolveMemberCell(raw: unknown, directory: MemberDirectory | null | undefined): ResolvedMemberCell;
+/**
+ * Validate a member value on WRITE, resolving the several things a human or an
+ * agent might reasonably pass — the member's email, or their display name when
+ * it is unambiguous — down to the canonical stored email.
+ *
+ * Returns null when nothing matched, so the caller can raise a typed error
+ * naming the workspace's actual members. Deliberately NOT lenient: a write is
+ * the one moment we can keep the column clean, and silently storing an
+ * unrecognised assignee is how an owner column rots back into free text.
+ */
+export declare function resolveMemberWriteValue(raw: unknown, directory: MemberDirectory): WorkspaceMemberRef | null;

package/node_modules/@oxygen/shared/dist/member-columns.js

@@ -0,0 +1,111 @@
+// Member-reference cells: an attribute whose value is a PERSON IN THIS
+// WORKSPACE — the record's owner/assignee. Attio calls the type an "actor
+// reference"; HubSpot calls the attribute "Deal owner". We ship one concept
+// under one name so a founder never has to hold both.
+//
+// STORAGE IS THE MEMBER'S EMAIL, in a `text` column, riding the same
+// semantic-over-text pattern as `markdown` and `image`: no new dataType, no new
+// WorkspaceColumnKind, so every existing filter, sort, CSV export, formula and
+// provider mapping keeps working unchanged.
+//
+// Email rather than the control-db user id, deliberately, and this is the one
+// place the two conventions diverge:
+//   - Collab (approvals) stores `assignee_user_ids` uuids and speaks email only
+//     at its API boundary. Correct there — those rows are control-plane-linked
+//     and never leave the product.
+//   - A CRM cell DOES leave the product. It lands in CSV exports, AI-column
+//     prompts, formula expressions, and outbound HubSpot/Attio owner mappings,
+//     all of which match on email. A uuid in any of those is an unreadable
+//     token that no downstream system can resolve.
+// The consequence to accept: an email is not an immutable handle. A member who
+// changes address leaves cells pointing at their old one, which is why
+// `resolveMemberCell` reports an unresolved value rather than dropping it.
+//
+// The DIRECTORY — who is a member, their display name, their avatar — is
+// control-plane state. tenant-db must never reach across that boundary, so
+// nothing here queries anything: the API layer supplies a directory and these
+// helpers stay pure.
+/** Canonical semantic for a member-reference column on any object. */
+export const MEMBER_COLUMN_SEMANTIC = "member";
+// `crm.owner` predates this type and already means exactly "a person in this
+// workspace owns this record" on the three standard objects. Treating it as a
+// member semantic rather than migrating it to `member` is what makes this
+// change reach every existing workspace with no column rewrite at all — the
+// stored VALUES converge on their own as owners are re-picked, and an
+// unresolved legacy string stays visible in the meantime.
+const MEMBER_COLUMN_SEMANTIC_ALIASES = ["crm.owner", "crm.assignee"];
+export function isMemberColumnSemantic(semanticType) {
+    if (!semanticType)
+        return false;
+    return (semanticType === MEMBER_COLUMN_SEMANTIC ||
+        MEMBER_COLUMN_SEMANTIC_ALIASES.includes(semanticType));
+}
+/**
+ * Canonical form of a member cell value: a lowercased, trimmed email.
+ *
+ * Anything that is not an email is preserved verbatim (trimmed) rather than
+ * rejected — existing `owner` columns are free text and hold real names typed
+ * by real founders. Losing "Philipp" on the way to a typed column would be a
+ * silent data deletion; carrying it as an unresolved value is honest and lets
+ * the owner picker repair it one click at a time.
+ */
+export function normalizeMemberCellValue(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    return looksLikeEmail(trimmed) ? trimmed.toLowerCase() : trimmed;
+}
+/** Build the lookup the render + validation paths use, keyed on lowercased email. */
+export function buildMemberDirectory(members) {
+    const directory = {};
+    for (const member of members) {
+        const email = normalizeMemberCellValue(member.email);
+        if (!email || !looksLikeEmail(email))
+            continue;
+        directory[email] = { ...member, email };
+    }
+    return directory;
+}
+/**
+ * Resolve one stored cell value against a directory. Pure, total, and never
+ * throws: a missing directory (the API layer could not reach the control plane)
+ * degrades every cell to `unresolved`, which shows the raw value instead of
+ * blanking a column — the same posture the activity timeline takes when link
+ * decoration fails.
+ */
+export function resolveMemberCell(raw, directory) {
+    const value = normalizeMemberCellValue(raw);
+    if (!value)
+        return { value: null, member: null, unresolved: false };
+    const member = directory?.[value.toLowerCase()] ?? null;
+    return { value, member: member ?? null, unresolved: !member };
+}
+/**
+ * Validate a member value on WRITE, resolving the several things a human or an
+ * agent might reasonably pass — the member's email, or their display name when
+ * it is unambiguous — down to the canonical stored email.
+ *
+ * Returns null when nothing matched, so the caller can raise a typed error
+ * naming the workspace's actual members. Deliberately NOT lenient: a write is
+ * the one moment we can keep the column clean, and silently storing an
+ * unrecognised assignee is how an owner column rots back into free text.
+ */
+export function resolveMemberWriteValue(raw, directory) {
+    const value = normalizeMemberCellValue(raw);
+    if (!value)
+        return null;
+    const byEmail = directory[value.toLowerCase()];
+    if (byEmail)
+        return byEmail;
+    // Name match, only when exactly one member answers to it. Two people called
+    // "Alex" must fail rather than have the write pick one of them.
+    const needle = value.toLowerCase();
+    const byName = Object.values(directory).filter((member) => member.name && member.name.trim().toLowerCase() === needle);
+    return byName.length === 1 ? (byName[0] ?? null) : null;
+}
+function looksLikeEmail(value) {
+    const at = value.indexOf("@");
+    return at > 0 && at < value.length - 1 && !/\s/.test(value);
+}

package/node_modules/@oxygen/shared/dist/microsoft-consent-url.js

@@ -1,5 +1,5 @@
 const MICROSOFT_LOGIN_HOST = "login.microsoftonline.com";
-const ADMIN_CONSENT_PATH = /^\/(?:[^/]+\/)?adminconsent\/?$/i;
+const ADMIN_CONSENT_PATH = /^\/(?:[^/]+\/)?(?:v2\.0\/)?adminconsent\/?$/i;
 /**
  * Normalize a Microsoft Entra admin-consent URL for an operator handoff.
  *

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

@@ -11,6 +11,22 @@ export declare function buildCopilotAttachmentObjectKey(input: {
     organizationId: string;
     fileName?: string | null;
 }): string;
+/**
+ * Mailbox avatars, which are unlike every other namespace here: their bytes are
+ * served back to an UNAUTHENTICATED third party (the inbox vendor fetches the
+ * URL server-side when it provisions the mailbox, possibly hours later).
+ *
+ * The object itself stays private — the bucket also holds customer lead lists —
+ * and a proxy route on our own domain reads it. So the two identifiers in the
+ * key are the whole access-control story: the org id scopes it, and the random
+ * UUID makes it unguessable. The file name is NOT caller-supplied; it comes from
+ * the sniffed image type, so the key can never carry attacker-chosen text.
+ */
+export declare function buildInboxAvatarObjectKey(input: {
+    organizationId: string;
+    fileName: string;
+}): string;
+export declare function isInboxAvatarObjectKeyForOrganization(key: string, organizationId: string): boolean;
 export declare function isImportObjectKeyForOrganization(key: string, organizationId: string): boolean;
 export declare function isCopilotAttachmentObjectKeyForOrganization(key: string, organizationId: string): boolean;
 export declare function isPublishingMediaObjectKeyForOrganization(key: string, organizationId: string): boolean;
@@ -61,6 +77,27 @@ export declare function getCopilotAttachmentObjectMetadata(input: {
     contentLength: number | null;
     contentType: string | null;
 }>;
+/**
+ * Read the LEADING BYTES of a staged import back out of the bucket.
+ *
+ * Bounded by `maxBytes` on purpose: the callers derive a header row, a column
+ * type sample and a row estimate, none of which needs the whole object — and a
+ * 100MB import must never become a 100MB buffer inside a Vercel handler. Same
+ * ranged-read shape as `readCopilotAttachmentObject`.
+ *
+ * Note on Content-Type: objects under `imports/` are written by a presigned PUT,
+ * and the S3 presigner marks content-type UNSIGNABLE — so the stored type is
+ * whatever the client claimed and is not covered by the signature. Never add a
+ * download, redirect or presigned-GET route over this prefix without pinning
+ * `ResponseContentType` and `ResponseContentDisposition: attachment`.
+ */
+export declare function readImportObject(input: {
+    storageKey: string;
+    maxBytes: number;
+}): Promise<{
+    body: Uint8Array;
+    truncated: boolean;
+}>;
 export declare function getImportObjectMetadata(input: {
     storageKey: string;
 }): Promise<{
@@ -82,6 +119,34 @@ export declare function presignPublishingMediaDownload(input: {
     storageKey: string;
     expiresInSeconds?: number;
 }): Promise<string>;
+export declare function presignInboxAvatarUpload(input: {
+    organizationId: string;
+    fileName: string;
+    contentType: string;
+    contentLength: number;
+}): Promise<PresignedImportUpload>;
+/**
+ * Read an avatar back, bounded. `maxBytes` is a hard stop rather than a hint:
+ * this is called from an unauthenticated route, so an object that somehow grew
+ * past the upload ceiling must not be able to turn one request into an
+ * unbounded buffer.
+ */
+export declare function readInboxAvatarObject(input: {
+    storageKey: string;
+    maxBytes: number;
+}): Promise<{
+    body: Uint8Array;
+    contentLength: number | null;
+    truncated: boolean;
+}>;
+export declare function getInboxAvatarObjectMetadata(input: {
+    storageKey: string;
+}): Promise<{
+    contentLength: number | null;
+}>;
+export declare function deleteInboxAvatarObject(input: {
+    storageKey: string;
+}): Promise<void>;
 export declare function deleteImportObject(input: {
     storageKey: string;
 }): Promise<void>;

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

@@ -69,6 +69,23 @@ export function buildCopilotAttachmentObjectKey(input) {
     const safeName = sanitizeFileName(input.fileName) || "attachment";
     return `copilot/${input.organizationId}/${randomUUID()}/${safeName}`;
 }
+/**
+ * Mailbox avatars, which are unlike every other namespace here: their bytes are
+ * served back to an UNAUTHENTICATED third party (the inbox vendor fetches the
+ * URL server-side when it provisions the mailbox, possibly hours later).
+ *
+ * The object itself stays private — the bucket also holds customer lead lists —
+ * and a proxy route on our own domain reads it. So the two identifiers in the
+ * key are the whole access-control story: the org id scopes it, and the random
+ * UUID makes it unguessable. The file name is NOT caller-supplied; it comes from
+ * the sniffed image type, so the key can never carry attacker-chosen text.
+ */
+export function buildInboxAvatarObjectKey(input) {
+    return `inbox-avatars/${input.organizationId}/${randomUUID()}/${input.fileName}`;
+}
+export function isInboxAvatarObjectKeyForOrganization(key, organizationId) {
+    return key.startsWith(`inbox-avatars/${organizationId}/`);
+}
 export function isImportObjectKeyForOrganization(key, organizationId) {
     return key.startsWith(`imports/${organizationId}/`);
 }
@@ -176,6 +193,34 @@ export async function getCopilotAttachmentObjectMetadata(input) {
         contentType: typeof result.ContentType === "string" ? result.ContentType : null,
     };
 }
+/**
+ * Read the LEADING BYTES of a staged import back out of the bucket.
+ *
+ * Bounded by `maxBytes` on purpose: the callers derive a header row, a column
+ * type sample and a row estimate, none of which needs the whole object — and a
+ * 100MB import must never become a 100MB buffer inside a Vercel handler. Same
+ * ranged-read shape as `readCopilotAttachmentObject`.
+ *
+ * Note on Content-Type: objects under `imports/` are written by a presigned PUT,
+ * and the S3 presigner marks content-type UNSIGNABLE — so the stored type is
+ * whatever the client claimed and is not covered by the signature. Never add a
+ * download, redirect or presigned-GET route over this prefix without pinning
+ * `ResponseContentType` and `ResponseContentDisposition: attachment`.
+ */
+export async function readImportObject(input) {
+    const { client, config } = resolveClient();
+    const result = await client.send(new GetObjectCommand({
+        Bucket: config.bucket,
+        Key: input.storageKey,
+        // One byte past the cap, so a full read is distinguishable from a file
+        // that happens to be exactly maxBytes long.
+        Range: `bytes=0-${input.maxBytes}`,
+    }));
+    const raw = await result.Body?.transformToByteArray();
+    const body = raw ?? new Uint8Array();
+    const truncated = body.byteLength > input.maxBytes;
+    return { body: truncated ? body.subarray(0, input.maxBytes) : body, truncated };
+}
 export async function getImportObjectMetadata(input) {
     const { client, config } = resolveClient();
     const result = await client.send(new HeadObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));
@@ -222,6 +267,61 @@ export async function presignPublishingMediaDownload(input) {
         expiresIn: input.expiresInSeconds ?? 60 * 60,
     });
 }
+export async function presignInboxAvatarUpload(input) {
+    const { client, config } = resolveClient();
+    const storageKey = buildInboxAvatarObjectKey({
+        organizationId: input.organizationId,
+        fileName: input.fileName,
+    });
+    const command = new PutObjectCommand({
+        Bucket: config.bucket,
+        Key: storageKey,
+        ContentLength: input.contentLength,
+        ContentType: input.contentType,
+    });
+    const uploadUrl = await getSignedUrl(client, command, { expiresIn: PRESIGN_EXPIRY_SECONDS });
+    return {
+        uploadUrl,
+        bucket: config.bucket,
+        storageKey,
+        contentLength: input.contentLength,
+        provider: "s3",
+        expiresInSeconds: PRESIGN_EXPIRY_SECONDS,
+    };
+}
+/**
+ * Read an avatar back, bounded. `maxBytes` is a hard stop rather than a hint:
+ * this is called from an unauthenticated route, so an object that somehow grew
+ * past the upload ceiling must not be able to turn one request into an
+ * unbounded buffer.
+ */
+export async function readInboxAvatarObject(input) {
+    const { client, config } = resolveClient();
+    const result = await client.send(new GetObjectCommand({
+        Bucket: config.bucket,
+        Key: input.storageKey,
+        Range: `bytes=0-${input.maxBytes}`,
+    }));
+    const raw = await result.Body?.transformToByteArray();
+    const body = raw ?? new Uint8Array();
+    const truncated = body.byteLength > input.maxBytes;
+    return {
+        body: truncated ? body.subarray(0, input.maxBytes) : body,
+        contentLength: typeof result.ContentLength === "number" ? result.ContentLength : null,
+        truncated,
+    };
+}
+export async function getInboxAvatarObjectMetadata(input) {
+    const { client, config } = resolveClient();
+    const result = await client.send(new HeadObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));
+    return {
+        contentLength: typeof result.ContentLength === "number" ? result.ContentLength : null,
+    };
+}
+export async function deleteInboxAvatarObject(input) {
+    const { client, config } = resolveClient();
+    await client.send(new DeleteObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));
+}
 export async function deleteImportObject(input) {
     const { client, config } = resolveClient();
     await client.send(new DeleteObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));

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

@@ -70,6 +70,7 @@ export type PlanLimits = {
         maxActionsPerRun: number;
     };
 };
+export { VERCEL_REQUEST_BODY_LIMIT_BYTES } from "./import-limits.js";
 /**
  * The per-rung limit matrix. `ai_live` deliberately equals `tool_live` at every
  * rung — one "live actions" mental model; the per-call cost asymmetry between
@@ -164,7 +165,7 @@ export declare const PLAN_LIMITS: {
             };
         };
         readonly import: {
-            readonly maxRowsPerFile: 50000;
+            readonly maxRowsPerFile: 250000;
             readonly maxFileBytes: number;
             readonly maxDirectCsvBodyBytes: 10000000;
         };

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

@@ -9,6 +9,10 @@ export const LIMITS_TIER_ORDER = [
 const HOUR = 60 * 60;
 const DAY = 24 * HOUR;
 const MIB = 1024 * 1024;
+// The platform request-body ceiling belongs to the same question as the import
+// ceilings below ("how big can an import be"), but it must stay importable from a
+// browser bundle, so it is defined in ./import-limits and re-exported here.
+export { VERCEL_REQUEST_BODY_LIMIT_BYTES } from "./import-limits.js";
 /**
  * The per-rung limit matrix. `ai_live` deliberately equals `tool_live` at every
  * rung — one "live actions" mental model; the per-call cost asymmetry between
@@ -34,8 +38,14 @@ export const PLAN_LIMITS = {
             import: { requestsPerMinute: 10, orgRequests: { limit: 100, windowSeconds: HOUR } },
         },
         import: {
-            maxRowsPerFile: 50_000,
-            maxFileBytes: 25 * MIB,
+            // Raised from 50k/25MiB in v1.717.0, when the web import modal moved onto
+            // the staged upload path. The old ceiling was set when every import had to
+            // squeeze through a request body; now the bytes go straight to object
+            // storage and the worker streams them, so the limit can describe what a
+            // trial workspace should be allowed to load rather than what the transport
+            // could survive.
+            maxRowsPerFile: 250_000,
+            maxFileBytes: 100 * MIB,
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {

package/node_modules/@oxygen/shared/dist/spend-safety.d.ts

@@ -42,6 +42,15 @@ export declare const DEFAULT_BYOK_COLUMN_RUN_MAX_ROWS: Record<PlanTier, number |
  */
 export declare const DEFAULT_BYOK_PROVIDER_DAILY_CALL_CAP: Record<PlanTier, number | null>;
 export declare const BYOK_PROVIDER_DAILY_WINDOW_SECONDS: number;
+export declare const BYOK_PROVIDER_DAILY_CAP_ENFORCEMENT_ENV = "OXYGEN_BYOK_DAILY_CAPS";
+export type ByokProviderDailyCapEnforcementMode = "observe_only" | "enforced";
+/**
+ * Runtime mode for the plan-scaled BYOK daily threshold. The default is
+ * deliberately observe-only while provider-volume telemetry is calibrated;
+ * explicit workspace provider policies remain independently enforced by the
+ * normal provider rate limiter.
+ */
+export declare function resolveByokProviderDailyCapEnforcementMode(configured?: string | undefined): ByokProviderDailyCapEnforcementMode;
 /**
  * Implicit org-level DAILY budget guard, evaluated only when the org has no
  * explicit org-scope daily budget policy and the plan has finite positive

package/node_modules/@oxygen/shared/dist/spend-safety.js

@@ -58,6 +58,16 @@ export const DEFAULT_BYOK_PROVIDER_DAILY_CALL_CAP = {
     enterprise: null,
 };
 export const BYOK_PROVIDER_DAILY_WINDOW_SECONDS = 24 * 60 * 60;
+export const BYOK_PROVIDER_DAILY_CAP_ENFORCEMENT_ENV = "OXYGEN_BYOK_DAILY_CAPS";
+/**
+ * Runtime mode for the plan-scaled BYOK daily threshold. The default is
+ * deliberately observe-only while provider-volume telemetry is calibrated;
+ * explicit workspace provider policies remain independently enforced by the
+ * normal provider rate limiter.
+ */
+export function resolveByokProviderDailyCapEnforcementMode(configured = process.env[BYOK_PROVIDER_DAILY_CAP_ENFORCEMENT_ENV]) {
+    return configured === "enforce" ? "enforced" : "observe_only";
+}
 /**
  * Implicit org-level DAILY budget guard, evaluated only when the org has no
  * explicit org-scope daily budget policy and the plan has finite positive

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

@@ -1,3 +1,3 @@
-export declare const OXYGEN_VERSION = "1.696.2";
+export declare const OXYGEN_VERSION = "1.717.1";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";

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

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.696.2";
+export const OXYGEN_VERSION = "1.717.1";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/node_modules/@oxygen/shared/package.json

@@ -21,6 +21,16 @@
       "import": "./dist/file-import.js",
       "default": "./dist/file-import.js"
     },
+    "./import-limits": {
+      "types": "./dist/import-limits.d.ts",
+      "import": "./dist/import-limits.js",
+      "default": "./dist/import-limits.js"
+    },
+    "./image-sniff": {
+      "types": "./dist/image-sniff.d.ts",
+      "import": "./dist/image-sniff.js",
+      "default": "./dist/image-sniff.js"
+    },
     "./mailbox-import": {
       "types": "./dist/mailbox-import.d.ts",
       "import": "./dist/mailbox-import.js",
@@ -36,6 +46,11 @@
       "import": "./dist/cell-format.js",
       "default": "./dist/cell-format.js"
     },
+    "./member-columns": {
+      "types": "./dist/member-columns.d.ts",
+      "import": "./dist/member-columns.js",
+      "default": "./dist/member-columns.js"
+    },
     "./column-types": {
       "types": "./dist/column-types.d.ts",
       "import": "./dist/column-types.js",
@@ -56,6 +71,11 @@
       "import": "./dist/suppression-entries.js",
       "default": "./dist/suppression-entries.js"
     },
+    "./dnc-identities": {
+      "types": "./dist/dnc-identities.d.ts",
+      "import": "./dist/dnc-identities.js",
+      "default": "./dist/dnc-identities.js"
+    },
     "./cli-result": {
       "types": "./dist/cli-result.d.ts",
       "import": "./dist/cli-result.js",