@oxygen-agent/cli 1.1010.721 → 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,6 +84,15 @@ 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;
+    };
 };
 /**
  * The per-rung Table import ceiling this matrix reports: today's envelope. The
@@ -88,6 +112,66 @@ 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
@@ -212,6 +296,9 @@ export declare const PLAN_LIMITS: {
         readonly tableActions: {
             readonly maxActionsPerRun: 10;
         };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 15;
+        };
     };
     readonly starter: {
         readonly cli: {
@@ -322,6 +409,9 @@ export declare const PLAN_LIMITS: {
         readonly tableActions: {
             readonly maxActionsPerRun: 25;
         };
+        readonly workflows: {
+            readonly cronMinIntervalMinutes: 1;
+        };
     };
     readonly pro: {
         readonly cli: {
@@ -426,12 +516,15 @@ 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: {
@@ -536,11 +629,14 @@ 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: {
@@ -646,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
@@ -662,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;

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

@@ -1,5 +1,7 @@
 import { resolveBasePricingPlan } from "./billing.js";
+import { OxygenError } from "./cli-result.js";
 import { WORKSPACE_TABLE_CAPACITY } from "./table-capacity.js";
+import { findRepricedValue, repricedValue } from "./repricing.js";
 export const LIMITS_TIER_ORDER = [
     "free",
     "starter",
@@ -31,6 +33,33 @@ 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 const MAX_CLI_JSON_BODY_BYTES = 2_000_000;
+/**
+ * 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 const DERIVED_PLAN_LIMIT_TARGETS = {
+    free: { importFileBytes: 500 * MIB, maxActionsPerRun: 10, signals: { maxEvents: 100, maxWindowDays: 30 } },
+    starter: { importFileBytes: 1_024 * MIB, maxActionsPerRun: 25, signals: { maxEvents: 200, maxWindowDays: 90 } },
+    pro: { importFileBytes: 2_048 * MIB, maxActionsPerRun: 25, signals: { maxEvents: 500, maxWindowDays: 180 } },
+    team: { importFileBytes: 5_120 * MIB, maxActionsPerRun: 50, signals: { maxEvents: 1_000, maxWindowDays: 365 } },
+    scale: { importFileBytes: 5_120 * MIB, maxActionsPerRun: 50, signals: { maxEvents: 1_000, maxWindowDays: 365 } },
+};
+/** The import file size a rung enforces (see `DERIVED_PLAN_LIMIT_TARGETS`). */
+export function importMaxFileBytesForTier(tier) {
+    return DERIVED_PLAN_LIMIT_TARGETS[tier].importFileBytes;
+}
 /**
  * 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
@@ -66,7 +95,7 @@ export const PLAN_LIMITS = {
         },
         import: {
             maxRowsPerFile: TABLE_IMPORT_ROW_LIMIT,
-            maxFileBytes: 100 * MIB,
+            maxFileBytes: importMaxFileBytesForTier("free"),
             maxDirectCsvBodyBytes: 10_000_000,
         },
         // Sized against the free tier's actual funding (OXP-10.2.4, 2026-08-17): one
@@ -90,8 +119,13 @@ export const PLAN_LIMITS = {
         // to complete one real Copilot session on the 1,000-credit signup grant
         // alone. Lowering this would re-create a dead-on-arrival Copilot.
         copilot: { maxSessionBudgetCredits: 500, defaultPerTurnCreditCeiling: 150 },
-        signals: { maxEvents: 100, maxWindowDays: 30 },
-        tableActions: { maxActionsPerRun: 10 },
+        signals: DERIVED_PLAN_LIMIT_TARGETS.free.signals,
+        tableActions: { maxActionsPerRun: DERIVED_PLAN_LIMIT_TARGETS.free.maxActionsPerRun },
+        // Decision L4.2 (ratified 2026-09-26): a free workspace schedules at most
+        // every 15 minutes, paid plans every minute. Dark until the repricing switch
+        // (FREE_CRON_MIN_INTERVAL_REPRICING); a faster schedule already armed is
+        // slowed to this interval at fire time, never deleted (proposal P-47).
+        workflows: { cronMinIntervalMinutes: 15 },
     },
     starter: {
         cli: {
@@ -113,7 +147,7 @@ export const PLAN_LIMITS = {
         },
         import: {
             maxRowsPerFile: TABLE_IMPORT_ROW_LIMIT,
-            maxFileBytes: 250 * MIB,
+            maxFileBytes: importMaxFileBytesForTier("starter"),
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
@@ -123,8 +157,9 @@ export const PLAN_LIMITS = {
             maxUpstreamCostUsdByok: 250,
         },
         copilot: { maxSessionBudgetCredits: 500, defaultPerTurnCreditCeiling: 150 },
-        signals: { maxEvents: 200, maxWindowDays: 90 },
-        tableActions: { maxActionsPerRun: 25 },
+        signals: DERIVED_PLAN_LIMIT_TARGETS.starter.signals,
+        tableActions: { maxActionsPerRun: DERIVED_PLAN_LIMIT_TARGETS.starter.maxActionsPerRun },
+        workflows: { cronMinIntervalMinutes: 1 },
     },
     pro: {
         cli: {
@@ -146,7 +181,7 @@ export const PLAN_LIMITS = {
         },
         import: {
             maxRowsPerFile: TABLE_IMPORT_ROW_LIMIT,
-            maxFileBytes: 250 * MIB,
+            maxFileBytes: importMaxFileBytesForTier("pro"),
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
@@ -156,8 +191,9 @@ export const PLAN_LIMITS = {
             maxUpstreamCostUsdByok: 250,
         },
         copilot: { maxSessionBudgetCredits: 1_000, defaultPerTurnCreditCeiling: 250 },
-        signals: { maxEvents: 200, maxWindowDays: 180 },
-        tableActions: { maxActionsPerRun: 25 },
+        signals: DERIVED_PLAN_LIMIT_TARGETS.pro.signals,
+        tableActions: { maxActionsPerRun: DERIVED_PLAN_LIMIT_TARGETS.pro.maxActionsPerRun },
+        workflows: { cronMinIntervalMinutes: 1 },
     },
     team: {
         cli: {
@@ -179,7 +215,7 @@ export const PLAN_LIMITS = {
         },
         import: {
             maxRowsPerFile: TABLE_IMPORT_ROW_LIMIT,
-            maxFileBytes: 250 * MIB,
+            maxFileBytes: importMaxFileBytesForTier("team"),
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
@@ -189,8 +225,9 @@ export const PLAN_LIMITS = {
             maxUpstreamCostUsdByok: 250,
         },
         copilot: { maxSessionBudgetCredits: 2_000, defaultPerTurnCreditCeiling: 500 },
-        signals: { maxEvents: 200, maxWindowDays: 365 },
-        tableActions: { maxActionsPerRun: 25 },
+        signals: DERIVED_PLAN_LIMIT_TARGETS.team.signals,
+        tableActions: { maxActionsPerRun: DERIVED_PLAN_LIMIT_TARGETS.team.maxActionsPerRun },
+        workflows: { cronMinIntervalMinutes: 1 },
     },
     scale: {
         cli: {
@@ -212,7 +249,7 @@ export const PLAN_LIMITS = {
         },
         import: {
             maxRowsPerFile: TABLE_IMPORT_ROW_LIMIT,
-            maxFileBytes: 250 * MIB,
+            maxFileBytes: importMaxFileBytesForTier("scale"),
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
@@ -222,10 +259,32 @@ export const PLAN_LIMITS = {
             maxUpstreamCostUsdByok: 250,
         },
         copilot: { maxSessionBudgetCredits: 5_000, defaultPerTurnCreditCeiling: 1_000 },
-        signals: { maxEvents: 200, maxWindowDays: 365 },
-        tableActions: { maxActionsPerRun: 25 },
+        signals: DERIVED_PLAN_LIMIT_TARGETS.scale.signals,
+        tableActions: { maxActionsPerRun: DERIVED_PLAN_LIMIT_TARGETS.scale.maxActionsPerRun },
+        workflows: { 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 function resolveCronMinIntervalMinutes(tier, options = {}) {
+    const scheduled = findRepricedValue(`workflows.${tier}.cron_min_interval_minutes`);
+    if (scheduled && typeof scheduled.before === "number" && typeof scheduled.after === "number") {
+        return repricedValue({ before: scheduled.before, after: scheduled.after }, options);
+    }
+    return PLAN_LIMITS[tier].workflows.cronMinIntervalMinutes;
+}
+/**
+ * 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 function highestCronMinIntervalMinutes(options = {}) {
+    return Math.max(...LIMITS_TIER_ORDER.map((tier) => resolveCronMinIntervalMinutes(tier, options)));
+}
 /**
  * Which enforcement rung a rung of the six-rung Oxygen plan lands on.
  *
@@ -269,3 +328,126 @@ export function limitsTierForPlanTier(tier) {
 export function planLimitsForTier(tier) {
     return PLAN_LIMITS[tier];
 }
+/**
+ * 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 function resolvePlanAgentCreditLimits(tier, options = {}) {
+    const agents = PLAN_LIMITS[tier].agents;
+    const resolve = (field, fallback) => {
+        const scheduled = findRepricedValue(`agents.${tier}.${field}`);
+        return scheduled && typeof scheduled.before === "number" && typeof scheduled.after === "number"
+            ? repricedValue({ before: scheduled.before, after: scheduled.after }, options)
+            : fallback;
+    };
+    return {
+        maxTotalCredits: resolve("max_total_credits", agents.maxTotalCredits),
+        maxInferenceCredits: resolve("max_inference_credits", agents.maxInferenceCredits),
+    };
+}
+/**
+ * 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 const AGENT_RUN_APPROVED_CEILING_MAX_CREDITS = 25_000;
+/**
+ * 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 function resolveAgentRunDefaultCeilings(input) {
+    const contract = input.enterpriseDefaultCredits;
+    if (typeof contract === "number" && Number.isFinite(contract) && contract >= 1) {
+        const total = Math.min(Math.floor(contract), AGENT_RUN_APPROVED_CEILING_MAX_CREDITS);
+        return {
+            maxTotalCredits: total,
+            maxInferenceCredits: Math.max(1, Math.floor(total / 2)),
+            source: "enterprise_contract",
+        };
+    }
+    return { ...resolvePlanAgentCreditLimits(input.tier, input.options), source: "plan" };
+}
+/** `details.approval_kind` on the refusal below, so every surface can render its own approval card. */
+export 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 function assertAgentRunCeilingApproval(input) {
+    const defaultMax = input.defaults.maxTotalCredits;
+    const subject = input.scope === "trigger" ? "each delivery of this trigger" : "this run";
+    if (input.maxCredits > AGENT_RUN_APPROVED_CEILING_MAX_CREDITS) {
+        throw new OxygenError("invalid_request", `max_credits ${input.maxCredits} is above the platform maximum of ${AGENT_RUN_APPROVED_CEILING_MAX_CREDITS} credits for ${subject}.`, {
+            exitCode: 2,
+            details: {
+                requested_max_credits: input.maxCredits,
+                default_max_credits: defaultMax,
+                platform_max_credits: AGENT_RUN_APPROVED_CEILING_MAX_CREDITS,
+            },
+        });
+    }
+    if (input.maxCredits <= defaultMax)
+        return { aboveDefault: false };
+    if (input.approveAboveDefault)
+        return { aboveDefault: true };
+    throw new OxygenError("approval_required", `max_credits ${input.maxCredits} is above your default Agent run ceiling of ${defaultMax} credits. Approve the higher ceiling for ${subject} with approve_above_default=true, or lower max_credits to ${defaultMax} or less.`, {
+        exitCode: 7,
+        details: {
+            approval_kind: AGENT_CEILING_ABOVE_DEFAULT_APPROVAL_KIND,
+            scope: input.scope,
+            requested_max_credits: input.maxCredits,
+            default_max_credits: defaultMax,
+            default_source: input.defaults.source,
+            platform_max_credits: AGENT_RUN_APPROVED_CEILING_MAX_CREDITS,
+            next_step: `Re-send with approve_above_default=true (CLI: --approve-above-default) to approve up to ${input.maxCredits} credits for ${subject}.`,
+        },
+    });
+}
+/**
+ * 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 function agentRunEnforcedCeilings(input) {
+    if (!input.aboveDefaultApproved) {
+        return {
+            maxTotalCredits: input.defaults.maxTotalCredits,
+            maxInferenceCredits: input.defaults.maxInferenceCredits,
+        };
+    }
+    return {
+        maxTotalCredits: AGENT_RUN_APPROVED_CEILING_MAX_CREDITS,
+        maxInferenceCredits: AGENT_RUN_APPROVED_CEILING_MAX_CREDITS,
+    };
+}