@oxygen-agent/cli 1.1010.721 → 1.1010.905

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";
@@ -111,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";
@@ -127,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/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;
+}

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

@@ -1,5 +1,6 @@
 import { type LimitsTier } from "./plan-limits.js";
-import type { RepricingOptions } from "./repricing.js";
+import { type RepricingOptions } from "./repricing.js";
+import { type WorkspaceTableCapacityStatus } from "./table-capacity.js";
 /**
  * The seven plan bands of the 2026-09 repricing (spec § 4, slice S06): free
  * plus one band per Oxygen plan size. They sit BESIDE the five-rung
@@ -15,6 +16,16 @@ export type PlanBand = "free" | "49" | "99" | "199" | "499" | "999" | "1999";
 export declare const PLAN_BAND_ORDER: readonly PlanBand[];
 /** The limits rung each band enforces at today. */
 export declare const PLAN_BAND_LIMITS_TIER: Readonly<Record<PlanBand, LimitsTier>>;
+/**
+ * L4.1 (repricing 2026-09, slice S55; decision record "Worker share"): a
+ * tenant's share of the legacy worker's tenant queue while other tenants wait.
+ * A weight-16 tenant gets sixteen quanta for every one a weight-1 tenant gets;
+ * with nobody else waiting every tenant is served at once, whatever its weight.
+ * It is a scheduling share, never a sold limit: capacity is sized so contention
+ * is rare (`.agents/skills/oxygen-worker-performance`, "Worker share target").
+ * An org whose band is not yet resolved schedules at the free weight.
+ */
+export declare const PLAN_BAND_WORKER_SHARE_WEIGHT: Readonly<Record<PlanBand, number>>;
 /**
  * PROPOSED (P-57, repricing spec § 4): a grandfathered or legacy plan takes the
  * band of the limits rung it enforces at today, so no grandfathered customer
@@ -42,6 +53,58 @@ export declare function planBandForLimitsResolution(resolution: {
 /** The band's monthly price, read from the Oxygen plan it names; null for free. */
 export declare function planBandMonthlyPriceCents(band: PlanBand): number | null;
 export declare function planBandLabel(band: PlanBand): string;
+/**
+ * PROPOSED (P-54): the free plan keeps a 50-credit default. It has no monthly
+ * grant to take 10% of (10% of its one-time 1,000 would be 100).
+ */
+export declare const FREE_PLAN_DEFAULT_DELIVERY_CREDIT_CEILING = 50;
+/**
+ * A plan size's target default delivery ceiling: 10% of its monthly credits,
+ * rounded half up (decision L5.1; the volume bonus counts, the partner bonus
+ * does not, P-54). This is the target, not always the value in force: see
+ * `resolveDefaultTriggerRunCreditCeilingForPlan`.
+ */
+export declare function planBandDeliveryCreditCeilingTarget(band: PlanBand): number;
+/** What an org's plan resolves to: the raw plan tier and its limits rung. */
+export type PlanSpendResolution = {
+    planTier: string | null;
+    limitsTier: LimitsTier;
+};
+/**
+ * The default credit ceiling of one LIVE workflow run fired by an unattended
+ * trigger (cron, webhook, event) that declares no `max_credits`, for a plan.
+ * `null` means no default applies (enterprise); an explicit cap always wins and
+ * is never clamped by this.
+ */
+export declare function resolveDefaultTriggerRunCreditCeilingForPlan(resolution: PlanSpendResolution, options?: RepricingOptions): number | null;
+/** The same default for one standing or webhook table auto-run batch. */
+export declare function resolveDefaultAutoRunBatchCreditCeilingForPlan(resolution: PlanSpendResolution, options?: RepricingOptions): number | null;
+/**
+ * Public webhook ingress (repricing 2026-09, decision L4.4, ratified
+ * 2026-09-26): deliveries a minute that one webhook target (a Table endpoint,
+ * a workflow or Agent trigger, the workspace's RB2B receiver) accepts. It used
+ * to be a flat 600 per target, with 60 per sender IP on most targets. Every
+ * value rises, so this is live on release rather than held behind the
+ * repricing switch.
+ */
+export declare const PUBLIC_WEBHOOK_INGRESS_PER_TARGET_PER_MINUTE: Readonly<Record<PlanBand, number>>;
+/**
+ * PROPOSED (P-50, repricing spec § 4.4): the decision raises the per-IP limit
+ * "to match", read as equal to the per-target limit (a share of 1). One sender
+ * (a form tool, a CRM) usually posts from one address, so any lower per-IP
+ * limit would cap a real integration below its plan's rate.
+ */
+export declare const PUBLIC_WEBHOOK_INGRESS_PER_IP_SHARE_OF_TARGET = 1;
+export declare const PUBLIC_WEBHOOK_INGRESS_WINDOW_SECONDS = 60;
+export type PublicWebhookIngressLimits = {
+    perTargetPerMinute: number;
+    perSenderIpPerMinute: number;
+    windowSeconds: number;
+};
+/** The webhook ingress limits a band enforces. */
+export declare function resolvePublicWebhookIngressLimits(band: PlanBand): PublicWebhookIngressLimits;
+/** The webhook ingress limits of one band, as the `/api/cli/limits` contract reports them. */
+export declare function describeWebhookIngress(band: PlanBand): PlanBandLimitsReport["webhooks"];
 /**
  * Request rates, per minute unless named otherwise. The totals bound every
  * `/api/cli/*` call; the operation buckets bind first for the calls a script
@@ -87,6 +150,15 @@ export type PlanBandLimitsReport = {
     label: string;
     monthly_price_usd: number | null;
     monthly_credits: number | null;
+    /**
+     * Credits granted above face value ($1 = 100 credits), repricing 2026-09
+     * decision 1.3: 0 up to $199, then +5% / +10% / +15% on $499 / $999 / $1,999.
+     * Already included in `monthly_credits`. Null on free, which has no plan grant.
+     */
+    volume_bonus_credits: number | null;
+    volume_bonus_percent: number | null;
+    /** What 100 plan credits cost on this size, the volume bonus included. */
+    usd_per_100_credits: number | null;
     limits_tier: LimitsTier;
     api: ApiRateLimitsReport;
     storage: {
@@ -97,22 +169,66 @@ export type PlanBandLimitsReport = {
         /** Equal to rows per Table (PROPOSED P-60): one file can fill an empty Table. */
         import_max_rows_per_file: number;
         import_max_file_bytes: number;
+        /**
+         * Where the values above stand against the ratified ladder (decision F.2):
+         * `in_force`, `scheduled` (they move to `target` at `effective_at`) or
+         * `awaiting_capacity_test` (`target` applies once the rows-per-Table
+         * capacity test at this size passes). A cut is announced only once the
+         * repricing date is set, so `target` is null while nothing is pending.
+         */
+        status: WorkspaceTableCapacityStatus["status"];
+        effective_at: string | null;
+        target: PlanBandStorageTarget | null;
     };
     spend: {
         trigger_run_credit_ceiling: number | null;
         auto_run_batch_credit_ceiling: number | null;
         agent_run_max_total_credits: number;
         agent_run_max_inference_credits: number;
+        /** Paid work the attended Copilot may start without an approval card. */
+        copilot_approval_free_per_call_credits: number;
+        copilot_approval_free_per_session_credits: number;
+        /** The platform's runaway bound on one attended Copilot turn (every plan). */
+        copilot_attended_turn_backstop_credits: number;
         org_daily_guard_warn_credits: number | null;
         org_daily_guard_block_credits: number | null;
         byok_column_run_max_rows: number | null;
         byok_provider_daily_calls: number | null;
     };
+    /**
+     * Table work limits (L6): rows one write request may carry, and columns one
+     * action run or standing auto-run may carry.
+     */
+    tables: {
+        max_rows_per_write_request: number;
+        max_columns_per_run: number;
+    };
+    /** The raw signal-event feed: events per read and look-back days. */
     signals: {
         max_events: number;
         max_window_days: number;
     };
+    /** Public webhook ingress, per target and per sender IP (decision L4.4). */
+    webhooks: {
+        ingress_requests_per_target_per_minute: number;
+        ingress_requests_per_sender_ip_per_minute: number;
+        window_seconds: number;
+    };
+    workflows: {
+        /** Fastest cron schedule a workflow or Agent trigger may use, in force now. */
+        cron_min_interval_minutes: number;
+    };
+};
+/** The storage values a band moves to, in the `/api/cli/limits` field names. */
+export type PlanBandStorageTarget = {
+    table_row_limit: number;
+    workspace_row_limit: number;
+    workspace_database_warning_bytes: number;
+    workspace_database_limit_bytes: number;
+    import_max_rows_per_file: number;
 };
+/** A band's storage status as `/api/cli/limits` reports it (`plan_bands[].storage` and `storage_capacity`). */
+export declare function describePlanBandStorageStatus(band: PlanBand, options?: RepricingOptions): Pick<PlanBandLimitsReport["storage"], "status" | "effective_at" | "target">;
 export declare function describePlanBandLimits(band: PlanBand, options?: RepricingOptions): PlanBandLimitsReport;
 /** Every band's limits in force today, smallest first. */
 export declare function describePlanBandLadder(options?: RepricingOptions): PlanBandLimitsReport[];