@oxygen-agent/cli 1.1010.650 → 1.1010.905

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

@@ -1,3 +1,4 @@
+import { type RepricingOptions } from "./repricing.js";
 /**
  * The five enforcement rungs of the per-plan limits ladder. Every PlanTier maps
  * onto exactly one rung: "free" doubles as the unentitled fallback (no live
@@ -8,6 +9,12 @@
  * Credits are the billing meter; these limits are abuse/runaway guards. They
  * are sized so legitimate interactive use never hits them and scale with plan
  * price so worst-case burn stays proportional to what the org pays.
+ *
+ * Org-scope unit budgets (`orgUnits`) bound row-weighted bulk volume only: a
+ * call whose normalized amount is 1 is counted against the budget but never
+ * refused by it, so single-item work is bounded by `requestsPerMinute` and the
+ * global `cli` buckets. A budget accumulated under a higher rung keeps refusing
+ * bulk calls until its window resets after a downgrade; there is no rebase.
  */
 export type LimitsTier = "free" | "starter" | "pro" | "team" | "scale";
 export declare const LIMITS_TIER_ORDER: readonly LimitsTier[];
@@ -16,7 +23,10 @@ export type OrgWindowLimit = {
     limit: number;
     windowSeconds: number;
 };
-/** Request bucket (per api-key / web-user scope) + org-scope unit budget. */
+/**
+ * Request bucket (per api-key / web-user scope) + org-scope unit budget. The
+ * unit budget never refuses a 1-unit call (rate-limits.ts `orgUnitBudget`).
+ */
 export type UnitPolicyLimits = {
     requestsPerMinute: number;
     orgUnits: OrgWindowLimit;
@@ -53,6 +63,11 @@ export type PlanLimits = {
         maxDirectCsvBodyBytes: number;
     };
     agents: {
+        /**
+         * The pre-2026-09-repricing default Agent run ceilings. Read the value in
+         * force with `resolvePlanAgentCreditLimits`: team and scale drop at the
+         * repricing instant.
+         */
         maxTotalCredits: number;
         maxInferenceCredits: number;
         maxUpstreamCostUsd: number;
@@ -69,14 +84,25 @@ export type PlanLimits = {
     tableActions: {
         maxActionsPerRun: number;
     };
+    /**
+     * `cronMinIntervalMinutes` is the fastest cron cadence a workflow or Agent
+     * trigger may be scheduled at (repricing 2026-09, decision L4.2). It is the
+     * ratified value; read the value in force with `resolveCronMinIntervalMinutes`,
+     * because the free rung's cut waits for the repricing switch.
+     */
+    workflows: {
+        cronMinIntervalMinutes: number;
+    };
 };
 /**
- * One platform-wide Table import ceiling. A file can fill an empty physical
- * Table exactly to its retained-row capacity on every plan; imports into a
- * non-empty Table remain subject to that Table's remaining capacity and the
- * workspace-wide capacity envelope.
+ * The per-rung Table import ceiling this matrix reports: today's envelope. The
+ * ceiling ENFORCED on an import is the workspace's plan-band rows-per-Table
+ * limit (`resolveWorkspaceTableCapacity`, PROPOSED P-60: a file can fill an
+ * empty Table exactly), which the web import paths resolve per organization.
+ * Imports into a non-empty Table remain subject to that Table's remaining
+ * capacity and the workspace-wide envelope.
  */
-export declare const TABLE_IMPORT_ROW_LIMIT: 3000000;
+export declare const TABLE_IMPORT_ROW_LIMIT: number;
 export { VERCEL_REQUEST_BODY_LIMIT_BYTES } from "./import-limits.js";
 /**
  * OXYGEN's own JSON-body ceiling for every `/api/cli/*` route (enforced by
@@ -86,57 +112,126 @@ export { VERCEL_REQUEST_BODY_LIMIT_BYTES } from "./import-limits.js";
  * in the CLI alone — an older server would still 413 at the old number.
  */
 export declare const MAX_CLI_JSON_BODY_BYTES = 2000000;
+/**
+ * Derived plan-scaled limits (repricing 2026-09 decision L6, spec § 4.7):
+ * import file size, columns per action run or standing auto-run and the signals
+ * feed. Each only rises against the pre-repricing ladder, so no paid customer
+ * loses a limit and nothing here waits for the effective-date switch. Rows per
+ * write request stay 5,000 free / 50,000 paid: the 2 MB request body
+ * (`MAX_CLI_JSON_BODY_BYTES`) binds first.
+ *
+ * `importFileBytes` is ratified (decision F.8, Philipp 2026-09-27): free 500 MiB,
+ * $49–$99 1 GiB, $199–$499 2 GiB, $999–$1,999 5 GiB. It is live on every plan
+ * and no longer waits for the per-Table capacity test: rows per Table still cap
+ * what one import can load, so a bigger file never buys more rows. 5 GiB is also
+ * the largest single PUT an S3-compatible store accepts
+ * (`IMPORT_OBJECT_SINGLE_PUT_MAX_BYTES`), which is the one upload a staged
+ * import makes.
+ */
+export declare const DERIVED_PLAN_LIMIT_TARGETS: {
+    readonly free: {
+        readonly importFileBytes: number;
+        readonly maxActionsPerRun: 10;
+        readonly signals: {
+            readonly maxEvents: 100;
+            readonly maxWindowDays: 30;
+        };
+    };
+    readonly starter: {
+        readonly importFileBytes: number;
+        readonly maxActionsPerRun: 25;
+        readonly signals: {
+            readonly maxEvents: 200;
+            readonly maxWindowDays: 90;
+        };
+    };
+    readonly pro: {
+        readonly importFileBytes: number;
+        readonly maxActionsPerRun: 25;
+        readonly signals: {
+            readonly maxEvents: 500;
+            readonly maxWindowDays: 180;
+        };
+    };
+    readonly team: {
+        readonly importFileBytes: number;
+        readonly maxActionsPerRun: 50;
+        readonly signals: {
+            readonly maxEvents: 1000;
+            readonly maxWindowDays: 365;
+        };
+    };
+    readonly scale: {
+        readonly importFileBytes: number;
+        readonly maxActionsPerRun: 50;
+        readonly signals: {
+            readonly maxEvents: 1000;
+            readonly maxWindowDays: 365;
+        };
+    };
+};
+/** The import file size a rung enforces (see `DERIVED_PLAN_LIMIT_TARGETS`). */
+export declare function importMaxFileBytesForTier(tier: LimitsTier): number;
 /**
  * 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
  * AI and tool calls is priced in credits, not throttled here.
+ *
+ * API rates follow the 2026-09 repricing (decision L2, ratified 2026-09-26):
+ * `cli.global` is the per-organization and per-key request total per minute,
+ * 1,200 / 3,000 / 6,000 / 12,000 / 30,000 from free to scale. The per-operation
+ * buckets below are PROPOSED (P-52, repricing spec § 4.2): each pre-repricing
+ * bucket multiplied by its rung's organization factor, 2x on free and 5x on
+ * every paid rung, and never above the rung's per-key total. `tenantSchema` and
+ * the flat `tenant_admin` guard in the web rate limiter are DDL abuse guards and
+ * stay unscaled.
  */
 export declare const PLAN_LIMITS: {
     readonly free: {
         readonly cli: {
             readonly global: {
-                readonly keyRequestsPerMinute: 120;
-                readonly orgRequestsPerMinute: 600;
+                readonly keyRequestsPerMinute: 1200;
+                readonly orgRequestsPerMinute: 1200;
             };
             readonly tenantRead: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 120;
                 readonly orgUnits: {
-                    readonly limit: 500000;
+                    readonly limit: 1000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 30;
+                readonly requestsPerMinute: 60;
                 readonly orgUnits: {
-                    readonly limit: 100000;
+                    readonly limit: 200000;
                     readonly windowSeconds: number;
                 };
             };
             readonly bulkImport: {
-                readonly requestsPerMinute: 10;
+                readonly requestsPerMinute: 20;
                 readonly orgRequests: {
-                    readonly limit: 100;
+                    readonly limit: 200;
                     readonly windowSeconds: number;
                 };
             };
             readonly aiLive: {
-                readonly requestsPerMinute: 20;
+                readonly requestsPerMinute: 40;
                 readonly orgRequests: {
-                    readonly limit: 100;
+                    readonly limit: 200;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolLive: {
-                readonly requestsPerMinute: 20;
+                readonly requestsPerMinute: 40;
                 readonly orgRequests: {
-                    readonly limit: 100;
+                    readonly limit: 200;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolDryRun: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 120;
                 readonly orgRequests: {
-                    readonly limit: 500;
+                    readonly limit: 1000;
                     readonly windowSeconds: number;
                 };
             };
@@ -151,36 +246,36 @@ export declare const PLAN_LIMITS: {
         };
         readonly web: {
             readonly tenantRead: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 240;
                 readonly orgUnits: {
-                    readonly limit: 1000000;
+                    readonly limit: 2000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 120;
                 readonly orgUnits: {
-                    readonly limit: 500000;
+                    readonly limit: 1000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly columnRun: {
-                readonly requestsPerMinute: 30;
+                readonly requestsPerMinute: 60;
                 readonly orgUnits: {
-                    readonly limit: 2000;
+                    readonly limit: 4000;
                     readonly windowSeconds: number;
                 };
             };
             readonly import: {
-                readonly requestsPerMinute: 10;
+                readonly requestsPerMinute: 20;
                 readonly orgRequests: {
-                    readonly limit: 100;
+                    readonly limit: 200;
                     readonly windowSeconds: number;
                 };
             };
         };
         readonly import: {
-            readonly maxRowsPerFile: 3000000;
+            readonly maxRowsPerFile: number;
             readonly maxFileBytes: number;
             readonly maxDirectCsvBodyBytes: 10000000;
         };
@@ -201,52 +296,55 @@ export declare const PLAN_LIMITS: {
         readonly tableActions: {
             readonly maxActionsPerRun: 10;
         };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 15;
+        };
     };
     readonly starter: {
         readonly cli: {
             readonly global: {
-                readonly keyRequestsPerMinute: 240;
-                readonly orgRequestsPerMinute: 600;
+                readonly keyRequestsPerMinute: 3000;
+                readonly orgRequestsPerMinute: 3000;
             };
             readonly tenantRead: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgUnits: {
-                    readonly limit: 25000000;
+                    readonly limit: 125000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgUnits: {
-                    readonly limit: 5000000;
+                    readonly limit: 25000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly bulkImport: {
-                readonly requestsPerMinute: 30;
+                readonly requestsPerMinute: 150;
                 readonly orgRequests: {
-                    readonly limit: 500;
+                    readonly limit: 2500;
                     readonly windowSeconds: number;
                 };
             };
             readonly aiLive: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 300;
                 readonly orgRequests: {
-                    readonly limit: 5000;
+                    readonly limit: 25000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolLive: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 300;
                 readonly orgRequests: {
-                    readonly limit: 5000;
+                    readonly limit: 25000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolDryRun: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 2000;
+                    readonly limit: 10000;
                     readonly windowSeconds: number;
                 };
             };
@@ -261,36 +359,36 @@ export declare const PLAN_LIMITS: {
         };
         readonly web: {
             readonly tenantRead: {
-                readonly requestsPerMinute: 300;
+                readonly requestsPerMinute: 1500;
                 readonly orgUnits: {
-                    readonly limit: 20000000;
+                    readonly limit: 100000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 180;
+                readonly requestsPerMinute: 900;
                 readonly orgUnits: {
-                    readonly limit: 10000000;
+                    readonly limit: 50000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly columnRun: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgUnits: {
-                    readonly limit: 500000;
+                    readonly limit: 2500000;
                     readonly windowSeconds: number;
                 };
             };
             readonly import: {
-                readonly requestsPerMinute: 30;
+                readonly requestsPerMinute: 150;
                 readonly orgRequests: {
-                    readonly limit: 500;
+                    readonly limit: 2500;
                     readonly windowSeconds: number;
                 };
             };
         };
         readonly import: {
-            readonly maxRowsPerFile: 3000000;
+            readonly maxRowsPerFile: number;
             readonly maxFileBytes: number;
             readonly maxDirectCsvBodyBytes: 10000000;
         };
@@ -311,52 +409,55 @@ export declare const PLAN_LIMITS: {
         readonly tableActions: {
             readonly maxActionsPerRun: 25;
         };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 1;
+        };
     };
     readonly pro: {
         readonly cli: {
             readonly global: {
-                readonly keyRequestsPerMinute: 240;
-                readonly orgRequestsPerMinute: 1200;
+                readonly keyRequestsPerMinute: 6000;
+                readonly orgRequestsPerMinute: 6000;
             };
             readonly tenantRead: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgUnits: {
-                    readonly limit: 50000000;
+                    readonly limit: 250000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgUnits: {
-                    readonly limit: 10000000;
+                    readonly limit: 50000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly bulkImport: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 300;
                 readonly orgRequests: {
-                    readonly limit: 1000;
+                    readonly limit: 5000;
                     readonly windowSeconds: number;
                 };
             };
             readonly aiLive: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 12000;
+                    readonly limit: 60000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolLive: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 12000;
+                    readonly limit: 60000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolDryRun: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 2000;
+                    readonly limit: 10000;
                     readonly windowSeconds: number;
                 };
             };
@@ -371,36 +472,36 @@ export declare const PLAN_LIMITS: {
         };
         readonly web: {
             readonly tenantRead: {
-                readonly requestsPerMinute: 600;
+                readonly requestsPerMinute: 3000;
                 readonly orgUnits: {
-                    readonly limit: 40000000;
+                    readonly limit: 200000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 360;
+                readonly requestsPerMinute: 1800;
                 readonly orgUnits: {
-                    readonly limit: 20000000;
+                    readonly limit: 100000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly columnRun: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgUnits: {
-                    readonly limit: 1000000;
+                    readonly limit: 5000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly import: {
-                readonly requestsPerMinute: 60;
+                readonly requestsPerMinute: 300;
                 readonly orgRequests: {
-                    readonly limit: 1000;
+                    readonly limit: 5000;
                     readonly windowSeconds: number;
                 };
             };
         };
         readonly import: {
-            readonly maxRowsPerFile: 3000000;
+            readonly maxRowsPerFile: number;
             readonly maxFileBytes: number;
             readonly maxDirectCsvBodyBytes: 10000000;
         };
@@ -415,58 +516,61 @@ export declare const PLAN_LIMITS: {
             readonly defaultPerTurnCreditCeiling: 250;
         };
         readonly signals: {
-            readonly maxEvents: 200;
+            readonly maxEvents: 500;
             readonly maxWindowDays: 180;
         };
         readonly tableActions: {
             readonly maxActionsPerRun: 25;
         };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 1;
+        };
     };
     readonly team: {
         readonly cli: {
             readonly global: {
-                readonly keyRequestsPerMinute: 240;
-                readonly orgRequestsPerMinute: 2400;
+                readonly keyRequestsPerMinute: 12000;
+                readonly orgRequestsPerMinute: 12000;
             };
             readonly tenantRead: {
-                readonly requestsPerMinute: 480;
+                readonly requestsPerMinute: 2400;
                 readonly orgUnits: {
-                    readonly limit: 100000000;
+                    readonly limit: 500000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 480;
+                readonly requestsPerMinute: 2400;
                 readonly orgUnits: {
-                    readonly limit: 25000000;
+                    readonly limit: 125000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly bulkImport: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 2000;
+                    readonly limit: 10000;
                     readonly windowSeconds: number;
                 };
             };
             readonly aiLive: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgRequests: {
-                    readonly limit: 30000;
+                    readonly limit: 150000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolLive: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgRequests: {
-                    readonly limit: 30000;
+                    readonly limit: 150000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolDryRun: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 2000;
+                    readonly limit: 10000;
                     readonly windowSeconds: number;
                 };
             };
@@ -481,36 +585,36 @@ export declare const PLAN_LIMITS: {
         };
         readonly web: {
             readonly tenantRead: {
-                readonly requestsPerMinute: 1200;
+                readonly requestsPerMinute: 6000;
                 readonly orgUnits: {
-                    readonly limit: 100000000;
+                    readonly limit: 500000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 720;
+                readonly requestsPerMinute: 3600;
                 readonly orgUnits: {
-                    readonly limit: 50000000;
+                    readonly limit: 250000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly columnRun: {
-                readonly requestsPerMinute: 480;
+                readonly requestsPerMinute: 2400;
                 readonly orgUnits: {
-                    readonly limit: 2500000;
+                    readonly limit: 12500000;
                     readonly windowSeconds: number;
                 };
             };
             readonly import: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 2000;
+                    readonly limit: 10000;
                     readonly windowSeconds: number;
                 };
             };
         };
         readonly import: {
-            readonly maxRowsPerFile: 3000000;
+            readonly maxRowsPerFile: number;
             readonly maxFileBytes: number;
             readonly maxDirectCsvBodyBytes: 10000000;
         };
@@ -525,58 +629,61 @@ export declare const PLAN_LIMITS: {
             readonly defaultPerTurnCreditCeiling: 500;
         };
         readonly signals: {
-            readonly maxEvents: 200;
+            readonly maxEvents: 1000;
             readonly maxWindowDays: 365;
         };
         readonly tableActions: {
-            readonly maxActionsPerRun: 25;
+            readonly maxActionsPerRun: 50;
+        };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 1;
         };
     };
     readonly scale: {
         readonly cli: {
             readonly global: {
-                readonly keyRequestsPerMinute: 240;
-                readonly orgRequestsPerMinute: 6000;
+                readonly keyRequestsPerMinute: 30000;
+                readonly orgRequestsPerMinute: 30000;
             };
             readonly tenantRead: {
-                readonly requestsPerMinute: 1000;
+                readonly requestsPerMinute: 5000;
                 readonly orgUnits: {
-                    readonly limit: 500000000;
+                    readonly limit: 2500000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 1000;
+                readonly requestsPerMinute: 5000;
                 readonly orgUnits: {
-                    readonly limit: 100000000;
+                    readonly limit: 500000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly bulkImport: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgRequests: {
-                    readonly limit: 5000;
+                    readonly limit: 25000;
                     readonly windowSeconds: number;
                 };
             };
             readonly aiLive: {
-                readonly requestsPerMinute: 600;
+                readonly requestsPerMinute: 3000;
                 readonly orgRequests: {
-                    readonly limit: 100000;
+                    readonly limit: 500000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolLive: {
-                readonly requestsPerMinute: 600;
+                readonly requestsPerMinute: 3000;
                 readonly orgRequests: {
-                    readonly limit: 100000;
+                    readonly limit: 500000;
                     readonly windowSeconds: number;
                 };
             };
             readonly toolDryRun: {
-                readonly requestsPerMinute: 120;
+                readonly requestsPerMinute: 600;
                 readonly orgRequests: {
-                    readonly limit: 2000;
+                    readonly limit: 10000;
                     readonly windowSeconds: number;
                 };
             };
@@ -591,36 +698,36 @@ export declare const PLAN_LIMITS: {
         };
         readonly web: {
             readonly tenantRead: {
-                readonly requestsPerMinute: 2000;
+                readonly requestsPerMinute: 10000;
                 readonly orgUnits: {
-                    readonly limit: 400000000;
+                    readonly limit: 2000000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly tenantWrite: {
-                readonly requestsPerMinute: 1500;
+                readonly requestsPerMinute: 7500;
                 readonly orgUnits: {
-                    readonly limit: 200000000;
+                    readonly limit: 1000000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly columnRun: {
-                readonly requestsPerMinute: 1000;
+                readonly requestsPerMinute: 5000;
                 readonly orgUnits: {
-                    readonly limit: 10000000;
+                    readonly limit: 50000000;
                     readonly windowSeconds: number;
                 };
             };
             readonly import: {
-                readonly requestsPerMinute: 240;
+                readonly requestsPerMinute: 1200;
                 readonly orgRequests: {
-                    readonly limit: 5000;
+                    readonly limit: 25000;
                     readonly windowSeconds: number;
                 };
             };
         };
         readonly import: {
-            readonly maxRowsPerFile: 3000000;
+            readonly maxRowsPerFile: number;
             readonly maxFileBytes: number;
             readonly maxDirectCsvBodyBytes: 10000000;
         };
@@ -635,14 +742,30 @@ export declare const PLAN_LIMITS: {
             readonly defaultPerTurnCreditCeiling: 1000;
         };
         readonly signals: {
-            readonly maxEvents: 200;
+            readonly maxEvents: 1000;
             readonly maxWindowDays: 365;
         };
         readonly tableActions: {
-            readonly maxActionsPerRun: 25;
+            readonly maxActionsPerRun: 50;
+        };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 1;
         };
     };
 };
+/**
+ * The fastest cron cadence, in minutes, a rung may schedule right now. The free
+ * rung's cut from every minute to every 15 (decision L4.2) is a tightening, so
+ * it resolves through the 2026-09 repricing switch: every minute until the
+ * effective instant, `PLAN_LIMITS.free.workflows.cronMinIntervalMinutes` from it.
+ */
+export declare function resolveCronMinIntervalMinutes(tier: LimitsTier, options?: RepricingOptions): number;
+/**
+ * The largest minimum cron interval any rung enforces right now. A schedule
+ * whose fires are never closer than this fits every plan, so a caller can skip
+ * the plan lookup for it.
+ */
+export declare function highestCronMinIntervalMinutes(options?: RepricingOptions): number;
 /**
  * Map a raw plan-tier string (subscription `tier`, metadata tier, legacy plan
  * key like `growth_250`, or an Oxygen rung key like `oxygen_499`) onto its
@@ -651,3 +774,89 @@ export declare const PLAN_LIMITS: {
  */
 export declare function limitsTierForPlanTier(tier: string | null | undefined): LimitsTier;
 export declare function planLimitsForTier(tier: LimitsTier): PlanLimits;
+/** The default credit ceilings of one Agent run on a rung. */
+export type PlanAgentCreditLimits = {
+    maxTotalCredits: number;
+    maxInferenceCredits: number;
+};
+/**
+ * The default credit ceilings of one Agent run in force on a rung right now.
+ *
+ * `PLAN_LIMITS[tier].agents` holds the values each rung read before the 2026-09
+ * repricing. The team and scale rungs drop to 2,500 total / 1,250 inference
+ * (decision L5.4, inference half PROPOSED P-56), and a cut waits for the
+ * effective-date switch (`agents.<tier>.*` in `REPRICING_2026_09_SCHEDULE`).
+ * Every Agent budget check reads this, never the table, so the cut lands
+ * everywhere at the same instant.
+ */
+export declare function resolvePlanAgentCreditLimits(tier: LimitsTier, options?: RepricingOptions): PlanAgentCreditLimits;
+/**
+ * The platform's hard backstop on one Agent run's approved credit ceiling
+ * (decision F.4, ratified 2026-09-27).
+ *
+ * The plan's Agent run ceiling is a DEFAULT: a run or trigger whose approved
+ * `max_credits` fits under it needs only the usual approval. Going above it
+ * takes a second, explicit per-run (or per-trigger) approval, and even that
+ * approval stops here. 25,000 credits ($250) is the largest standing
+ * per-delivery default any plan has carried (the pre-2026-09 scale trigger
+ * default), so an approved Agent run never outspends one delivery of the
+ * largest plan's own automation. The other backstops stay in force whatever is
+ * approved: the plan's upstream-USD clamp, the iteration, tool-call and
+ * active-minute bounds, the balance check on every reservation and the org
+ * daily spend guard.
+ */
+export declare const AGENT_RUN_APPROVED_CEILING_MAX_CREDITS = 25000;
+/** Where an org's default Agent run ceiling came from. */
+export type AgentRunDefaultCeilingSource = "plan" | "enterprise_contract";
+/** The Agent run ceilings an org's runs are held to without a further approval. */
+export type AgentRunDefaultCeilings = PlanAgentCreditLimits & {
+    source: AgentRunDefaultCeilingSource;
+};
+/**
+ * The default Agent run ceilings for an org: its plan rung's, unless an
+ * enterprise contract names its own default (decision F.4). The contract value
+ * replaces the rung's total and model calls take half of it, as on every paid
+ * rung. A contract value is clamped to the platform backstop; an unusable one
+ * (absent, non-numeric, not positive) is ignored.
+ */
+export declare function resolveAgentRunDefaultCeilings(input: {
+    tier: LimitsTier;
+    enterpriseDefaultCredits?: number | null;
+    options?: RepricingOptions;
+}): AgentRunDefaultCeilings;
+/** `details.approval_kind` on the refusal below, so every surface can render its own approval card. */
+export declare const AGENT_CEILING_ABOVE_DEFAULT_APPROVAL_KIND = "agent_ceiling_above_default";
+/**
+ * Check one run's (or one trigger's per-delivery) approved ceiling against the
+ * org's default before anything is created.
+ *
+ * - At or under the default: nothing more to approve.
+ * - Above it: refused with `approval_required` unless the caller also passed the
+ *   explicit above-default approval. The details carry the numbers and the flag
+ *   each surface re-sends, so the refusal is the approval card.
+ * - Above the platform backstop: refused outright; no approval raises it.
+ *
+ * Returns whether the approved ceiling is above the default; the caller persists
+ * that as the run's or trigger's above-default approval.
+ */
+export declare function assertAgentRunCeilingApproval(input: {
+    maxCredits: number;
+    defaults: AgentRunDefaultCeilings;
+    approveAboveDefault: boolean;
+    /** "run" for one run, "trigger" for a trigger's per-delivery ceiling. */
+    scope: "run" | "trigger";
+}): {
+    aboveDefault: boolean;
+};
+/**
+ * The ceilings one run is held to, for the worker and every budget check that
+ * reads a run's authority. A run with a recorded above-default approval is
+ * bounded by its own approved `max_credits` (applied by the caller as a user
+ * limit) under the platform backstop. Every other run is bounded by the default,
+ * so a ceiling approved without the second approval — including every one
+ * approved before this rule — still binds at the default exactly as before.
+ */
+export declare function agentRunEnforcedCeilings(input: {
+    defaults: PlanAgentCreditLimits;
+    aboveDefaultApproved: boolean;
+}): PlanAgentCreditLimits;