@oxygen-agent/cli 1.1010.721 → 1.1010.905

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

@@ -33,6 +33,21 @@ export declare function parseRepricingEffectiveAt(raw: string | undefined): Date
 export declare function readRepricingSwitch(options?: RepricingOptions): RepricingSwitchState;
 /** True once the switch names an instant that has passed. */
 export declare function isRepricingInForce(options?: RepricingOptions): boolean;
+/**
+ * The value an entry moves to and when, only while the switch names an instant
+ * still ahead (`scheduled`). `null` when unset, invalid or already in force, so a
+ * marketing surface that quotes "$1.25, $1.30 from <date>" announces nothing
+ * until an operator sets the date and stops announcing once the new value is
+ * the one in force.
+ */
+export declare function scheduledRepricedValue<T extends RepricedScalar>(value: {
+    readonly after: T;
+}, options?: RepricingOptions): {
+    value: Widen<T>;
+    effectiveAt: Date;
+} | null;
+/** "October 27, 2026": how marketing copy names the switch's instant, in UTC. */
+export declare function formatRepricingDate(effectiveAt: Date): string;
 /**
  * A price or limit value. `null` means "no bound", and only a limit's `before`
  * may hold it: a limit that did not exist and now does is a tightening that
@@ -70,6 +85,14 @@ export declare const EMAIL_MAILBOX_DAILY_CAP_MAXIMUM: RepricedValue<number | nul
  * setting the cap again records it as the customer's own, and it is then kept.
  */
 export declare const EMAIL_MAILBOX_OLD_DEFAULT_DAILY_CAP: RepricedValue<25 | 40>;
+/**
+ * S10 (decision 1.5): 100 on-demand top-up credits cost $1.30, up from $1.25.
+ * The seed and the generated snapshot carry the new rate; the rate sold until
+ * now stays in force until the switch's instant. `creditTopupUsdCentsPer100()`
+ * in billing.ts is the one runtime reader, and the packs on offer move with it
+ * (`creditTopupPacks()`, proposal P-7).
+ */
+export declare const TOPUP_RATE_REPRICING: RepricedValue<125 | 130>;
 /**
  * S20: the monthly credit reservation of every connected account (decisions
  * 2.1–2.4). Each key is the pricing-seed charge key, so the seed row carries the
@@ -80,6 +103,110 @@ export declare const EMAIL_MAILBOX_OLD_DEFAULT_DAILY_CAP: RepricedValue<25 | 40>
  * rather than in credits. Such a kind reserves nothing until the instant.
  */
 export declare const S20_RESERVATION_PRICE_RISES: readonly RepricedValue<number>[];
+/**
+ * S40 (decision 6.1): a workflow step costs 0.05 credits, up from 0.001 per
+ * action. The seed and the generated snapshot carry the new price; the price
+ * charged until now stays in force until the switch's instant. Row writes inside
+ * a run are not steps and bill nothing (decision 6.2, live on release because it
+ * is a decrease), so the rise applies to steps only.
+ */
+export declare const AUTOMATION_STEP_CREDITS_REPRICING: RepricedValue<0.001 | 0.05>;
+/**
+ * S40 (proposal P-45): once a step costs real money, the steps a live run
+ * executes count toward that run's approved `max_credits` and a trigger's
+ * per-delivery ceiling, next to its paid tool calls. Counting them tightens an
+ * approved ceiling, so it starts with the price and not before.
+ */
+export declare const AUTOMATION_STEPS_COUNT_TOWARD_RUN_CAP_REPRICING: RepricedValue<boolean>;
+/**
+ * S30 (decision 3.5): EmailGuard monitoring per subscribed inbox, including the
+ * cycle's placement-test allowance, 100 -> 135 credits a month. Existing
+ * subscriptions pay the price in force at each renewal.
+ */
+export declare const DELIVERABILITY_SEAT_REPRICING: RepricedValue<100 | 135>;
+/**
+ * S30 (decision 3.6; flat literal, proposal P-29): one managed placement test
+ * past an inbox's included allowance, or on an inbox with no monitoring
+ * subscription, 16.6 -> 66 credits. Tests on your own EmailGuard key stay 0.
+ */
+export declare const PLACEMENT_TEST_REPRICING: RepricedValue<16.6 | 66>;
+/** EmailGuard monitoring per subscribed inbox-month, in credits, at the price in force. */
+export declare function deliverabilitySeatCredits(options?: RepricingOptions): number;
+/** One managed placement test beyond the included allowance, in credits, at the price in force. */
+export declare function placementTestCredits(options?: RepricingOptions): number;
+/** The flat monthly mailbox line of a managed Google inbox (the pricing seed's `commitment.managed_mailbox`). */
+export declare const MANAGED_MAILBOX_REPRICING: RepricedValue<300 | 400>;
+/** What a managed Google inbox costs a month, all-in: mailbox, connection and warm-up. */
+export declare const MANAGED_INBOX_ALL_IN_REPRICING: RepricedValue<number>;
+/** A managed Google inbox's monthly credits, all-in, at the switch state (marketing and docs). */
+export declare function managedInboxAllInCredits(options?: RepricingOptions): number;
+/**
+ * S41 (decision 6.3): a provider call made with the customer's own API key
+ * (BYOK) pays a 0.05-credit platform fee, up from nothing. The vendor still
+ * bills the call itself. The seed and the generated snapshot carry the fee; it
+ * is 0 until the switch's instant. Standing permissions approved while BYOK was
+ * free (armed auto-runs, workflow triggers) pay it from then on inside the
+ * per-delivery ceiling they already carry (proposal P-67).
+ */
+export declare const BYOK_PLATFORM_FEE_REPRICING: RepricedValue<0 | 0.05>;
+/**
+ * L5.1 (decision L5.1; the free value and the rounding are PROPOSED P-54): the
+ * default credit ceiling of one unattended delivery is 10% of the plan's
+ * monthly credits, rounded half up. Integer arithmetic, because
+ * `229_885 * 0.1` is 22988.4999... in floating point and rounds the wrong way.
+ */
+export declare function tenthOfMonthlyCreditsRoundedHalfUp(monthlyCredits: number): number;
+export declare const S56_DELIVERY_CREDIT_CEILING_CUTS: readonly RepricedValue<number>[];
+/**
+ * L5.2 (decision L5.2): the free plan gains a default daily runaway guard. Free
+ * had none, because the guard scales from a monthly grant free does not have,
+ * so the guard itself is the tightening: no bound before the instant.
+ */
+export declare const FREE_ORG_DAILY_GUARD_WARN_CREDITS: RepricedValue<number | null>;
+export declare const FREE_ORG_DAILY_GUARD_BLOCK_CREDITS: RepricedValue<number | null>;
+/**
+ * L5.4 (decision L5.4; the inference half is PROPOSED P-56): the default credit
+ * ceilings of one Agent run on the team and scale limits rungs, which the $999
+ * and $1,999 plans, grandfathered Team plans and legacy scale plans read. A
+ * customer can still approve a higher ceiling for a single run.
+ */
+export declare const S56_AGENT_RUN_LIMIT_CUTS: readonly RepricedValue<number>[];
+/**
+ * S53 (decision L4.2, ratified 2026-09-26): a free workspace may schedule a
+ * workflow or Agent cron at most every 15 minutes, down from every minute. Paid
+ * plans keep every minute. A new schedule that fires closer together is refused
+ * with `cron_interval_below_plan_minimum`; one already armed keeps running at the
+ * 15-minute interval instead and is never deleted (proposal P-47).
+ * `resolveCronMinIntervalMinutes` in plan-limits.ts resolves it, and a test pins
+ * `after` to `PLAN_LIMITS.free.workflows.cronMinIntervalMinutes`.
+ */
+export declare const FREE_CRON_MIN_INTERVAL_REPRICING: RepricedValue<1 | 15>;
+/** A Lusha person enrichment that reveals a phone number, per contact. */
+export declare const LUSHA_PHONE_REVEAL_CREDITS_REPRICING: RepricedValue<43.5 | 217.5>;
+/** A Lusha person enrichment that reveals an email and a phone number, per contact. */
+export declare const LUSHA_EMAIL_AND_PHONE_REVEAL_CREDITS_REPRICING: RepricedValue<43.5 | 261>;
+/**
+ * Before the instant a Lusha or Apollo bulk person enrichment never costs more
+ * than its old flat price per request (43.5 and 100); from it on, it costs its
+ * per-record price times the contacts or records it holds.
+ */
+export declare const PERSON_REVEAL_PRICED_PER_RECORD_REPRICING: RepricedValue<boolean>;
+export declare const S42_REVEAL_PRICE_RISES: readonly RepricedValue[];
+/** Whether the LinkedIn-URL waterfall bills a flat price per URL found. */
+export declare const LINKEDIN_URL_FLAT_PRICE_REPRICING: RepricedValue<boolean>;
+/** True once a LinkedIn URL is priced per URL found (S43). */
+export declare function linkedinUrlFlatPriceInForce(options?: RepricingOptions): boolean;
+/** The flat price of one LinkedIn URL found, in credits (the pricing seed's `enrichment.linkedin_url_found`). */
+export declare function linkedinUrlFoundCredits(): number;
+/**
+ * S22 (decision 2.7): bringing your own provider keys (BYOK) needs the $99 plan
+ * or above. The pricing seed and snapshot carry the new value (`oxygen_49`
+ * `byokEnabled: false`); `resolveBasePricingPlan` holds the $49 plan at the old
+ * value until the switch's instant. From the instant on, a key the workspace
+ * connected before it keeps working until the plan changes (P-20, proposed):
+ * `byokConnectionGrandfathered` in plan-capabilities.ts.
+ */
+export declare const OXYGEN_49_BYOK_REPRICING: RepricedValue<boolean>;
 /**
  * Every value the 2026-09 switch moves. Each dark slice appends its entries
  * here, so `oxygen limits show` can list them once a date is set and one test

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

@@ -41,10 +41,12 @@
 // tests drive both states, and an operator's change must not need a restart to
 // be seen consistently. Parsing one short string per call is negligible.
 //
-// No imports on purpose: `@oxygen/shared` ships inside the published CLI, and
-// "use client" components may import the schedule. A client component cannot
-// read the server's environment, though, so a page that shows a price in force
-// must resolve it on the server and pass it down.
+// Its only import is the generated pricing snapshot, which is literals only:
+// `@oxygen/shared` ships inside the published CLI, and "use client" components
+// may import the schedule. A client component cannot read the server's
+// environment, though, so a page that shows a price in force must resolve it on
+// the server and pass it down.
+import { AUTOMATION_ACTION_CREDITS as SNAPSHOT_AUTOMATION_STEP_CREDITS, DELIVERABILITY_SEAT_CREDITS_PER_MONTH as SNAPSHOT_DELIVERABILITY_SEAT_CREDITS, PLACEMENT_TEST_OVERAGE_CREDITS as SNAPSHOT_PLACEMENT_TEST_CREDITS, BYOK_PLATFORM_FEE_CREDITS as SNAPSHOT_BYOK_PLATFORM_FEE_CREDITS, LINKEDIN_URL_FOUND_CREDITS as SNAPSHOT_LINKEDIN_URL_FOUND_CREDITS, MANAGED_INBOX_CREDITS_PER_MONTH as SNAPSHOT_MANAGED_MAILBOX_CREDITS, PRICING_PLAN_SNAPSHOT, SENDING_MAILBOX_CREDITS_PER_MONTH as SNAPSHOT_SENDING_MAILBOX_CREDITS, TOPUP_USD_CENTS_PER_100_CREDITS as SNAPSHOT_TOPUP_USD_CENTS_PER_100_CREDITS, } from "./pricing-snapshot.generated.js";
 export const REPRICING_2026_09_EFFECTIVE_AT_ENV_VAR = "OXYGEN_REPRICING_2026_09_EFFECTIVE_AT";
 /** Stable machine name of this price change, as reported on customer surfaces. */
 export const REPRICING_2026_09_NAME = "repricing_2026_09";
@@ -91,6 +93,23 @@ export function readRepricingSwitch(options = {}) {
 export function isRepricingInForce(options = {}) {
     return readRepricingSwitch(options).status === "in_force";
 }
+/**
+ * The value an entry moves to and when, only while the switch names an instant
+ * still ahead (`scheduled`). `null` when unset, invalid or already in force, so a
+ * marketing surface that quotes "$1.25, $1.30 from <date>" announces nothing
+ * until an operator sets the date and stops announcing once the new value is
+ * the one in force.
+ */
+export function scheduledRepricedValue(value, options = {}) {
+    const state = readRepricingSwitch(options);
+    if (state.status !== "scheduled")
+        return null;
+    return { value: value.after, effectiveAt: state.effectiveAt };
+}
+/** "October 27, 2026": how marketing copy names the switch's instant, in UTC. */
+export function formatRepricingDate(effectiveAt) {
+    return effectiveAt.toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric", timeZone: "UTC" });
+}
 /** The value in force: `before` until the switch's instant, `after` from it on. */
 export function repricedValue(value, options = {}) {
     return (isRepricingInForce(options) ? value.after : value.before);
@@ -100,9 +119,10 @@ export function defineRepricedValue(definition) {
 }
 const GIB = 1024 ** 3;
 // S50 (decision L1, ratified 2026-09-26): the storage limits that TIGHTEN, per
-// plan band. Today every band has 3,000,000 rows per Table, 25,000,000 per
+// plan band. Before it every band had 3,000,000 rows per Table, 25,000,000 per
 // workspace and 30 GiB (warning at 20 GiB). $199 and $499 keep those values, and
-// $999 / $1,999 rise only after the capacity test at 5M and 10M rows, so only
+// $999 / $1,999 only rise (workspace totals at once, decision F.1; rows per Table
+// after the capacity test at 5M and 10M rows), so only
 // free, $49 and $99 appear here. The database warning is PROPOSED P-48: two
 // thirds of the hard limit, rounded down to a whole byte.
 // `packages/shared/src/table-capacity.ts` resolves these; a test pins each
@@ -165,6 +185,23 @@ export const EMAIL_MAILBOX_OLD_DEFAULT_DAILY_CAP = defineRepricedValue({
     before: 40,
     after: 25,
 });
+/**
+ * S10 (decision 1.5): 100 on-demand top-up credits cost $1.30, up from $1.25.
+ * The seed and the generated snapshot carry the new rate; the rate sold until
+ * now stays in force until the switch's instant. `creditTopupUsdCentsPer100()`
+ * in billing.ts is the one runtime reader, and the packs on offer move with it
+ * (`creditTopupPacks()`, proposal P-7).
+ */
+export const TOPUP_RATE_REPRICING = defineRepricedValue({
+    key: "topup.usd_cents_per_100_credits",
+    kind: "price",
+    slice: "S10",
+    decision: "1.5",
+    unit: "usd_cents_per_100_credits",
+    description: "Price of 100 on-demand top-up credits, in US cents. Purchased credits never expire.",
+    before: 125,
+    after: SNAPSHOT_TOPUP_USD_CENTS_PER_100_CREDITS,
+});
 /**
  * S20: the monthly credit reservation of every connected account (decisions
  * 2.1–2.4). Each key is the pricing-seed charge key, so the seed row carries the
@@ -216,6 +253,354 @@ export const S20_RESERVATION_PRICE_RISES = [
         after: 1_000,
     }),
 ];
+/**
+ * S40 (decision 6.1): a workflow step costs 0.05 credits, up from 0.001 per
+ * action. The seed and the generated snapshot carry the new price; the price
+ * charged until now stays in force until the switch's instant. Row writes inside
+ * a run are not steps and bill nothing (decision 6.2, live on release because it
+ * is a decrease), so the rise applies to steps only.
+ */
+export const AUTOMATION_STEP_CREDITS_REPRICING = defineRepricedValue({
+    key: "workflows.automation_step_credits",
+    kind: "price",
+    slice: "S40",
+    decision: "6.1",
+    unit: "credits per workflow step",
+    description: "Each step a live workflow run executes. Row writes inside a run are free.",
+    before: 0.001,
+    after: SNAPSHOT_AUTOMATION_STEP_CREDITS,
+});
+/**
+ * S40 (proposal P-45): once a step costs real money, the steps a live run
+ * executes count toward that run's approved `max_credits` and a trigger's
+ * per-delivery ceiling, next to its paid tool calls. Counting them tightens an
+ * approved ceiling, so it starts with the price and not before.
+ */
+export const AUTOMATION_STEPS_COUNT_TOWARD_RUN_CAP_REPRICING = defineRepricedValue({
+    key: "workflows.steps_count_toward_max_credits",
+    kind: "limit",
+    slice: "S40",
+    decision: "6.1",
+    unit: "boolean",
+    description: "Workflow step credits count toward a run's max_credits and a trigger's per-delivery ceiling.",
+    before: false,
+    after: true,
+});
+// ---- S30 (decisions 3.5 and 3.6): EmailGuard back on the 5x markup. -------
+// Both keys are the pricing-seed charge keys, so the seed row and the snapshot
+// carry the new price, `after` reads it from the snapshot (one definition), and
+// `repricedChargeCredits` / `repricedValue` hold the old price until the instant.
+/**
+ * S30 (decision 3.5): EmailGuard monitoring per subscribed inbox, including the
+ * cycle's placement-test allowance, 100 -> 135 credits a month. Existing
+ * subscriptions pay the price in force at each renewal.
+ */
+export const DELIVERABILITY_SEAT_REPRICING = defineRepricedValue({
+    key: "commitment.deliverability_unit",
+    kind: "price",
+    slice: "S30",
+    decision: "3.5",
+    unit: "credits_per_inbox_per_month",
+    description: "EmailGuard monitoring per subscribed inbox, including its included placement tests each cycle.",
+    before: 100,
+    after: SNAPSHOT_DELIVERABILITY_SEAT_CREDITS,
+});
+/**
+ * S30 (decision 3.6; flat literal, proposal P-29): one managed placement test
+ * past an inbox's included allowance, or on an inbox with no monitoring
+ * subscription, 16.6 -> 66 credits. Tests on your own EmailGuard key stay 0.
+ */
+export const PLACEMENT_TEST_REPRICING = defineRepricedValue({
+    key: "overage.placement_test",
+    kind: "price",
+    slice: "S30",
+    decision: "3.6",
+    unit: "credits_per_test",
+    description: "One managed inbox-placement test beyond an inbox's included tests. Tests on your own EmailGuard key cost 0.",
+    before: 16.6,
+    after: SNAPSHOT_PLACEMENT_TEST_CREDITS,
+});
+/** EmailGuard monitoring per subscribed inbox-month, in credits, at the price in force. */
+export function deliverabilitySeatCredits(options = {}) {
+    return repricedValue(DELIVERABILITY_SEAT_REPRICING, options);
+}
+/** One managed placement test beyond the included allowance, in credits, at the price in force. */
+export function placementTestCredits(options = {}) {
+    return repricedValue(PLACEMENT_TEST_REPRICING, options);
+}
+// ---- S32 (decision 3.1): a managed Google inbox at 500 credits all-in. ----
+// Until the instant, a managed mailbox is priced at the inbox vendor's cost x 1.2
+// (300 credits for Google at $2.50) and its warm-up add-on bills 100 on top. From
+// it, a Google mailbox is a flat 400 plus the 100-credit mailbox connection every
+// sending mailbox holds, 500 in total, with warm-up included in the connection.
+// Microsoft and Azure keep their cost-derived mailbox or tenant price (proposals
+// P-25, P-26) and gain the same included warm-up and connection.
+//
+// The switch alone does not move it. `isManagedInboxAllInPriceActive`
+// (@oxygen/integrations) also requires credit commitments to bill
+// `sending_mailbox` and `managed_mailbox` (the S26 arming): otherwise the order
+// would drop to 400 while nobody collects the connection it includes.
+/** The flat monthly mailbox line of a managed Google inbox (the pricing seed's `commitment.managed_mailbox`). */
+export const MANAGED_MAILBOX_REPRICING = defineRepricedValue({
+    key: "commitment.managed_mailbox",
+    kind: "price",
+    slice: "S32",
+    decision: "3.1",
+    unit: "credits_per_inbox_per_month",
+    description: "The mailbox line of a managed Google inbox, a flat price. Its 100-credit mailbox connection, with warm-up included, is billed beside it.",
+    before: 300,
+    after: SNAPSHOT_MANAGED_MAILBOX_CREDITS,
+});
+/** What a managed Google inbox costs a month, all-in: mailbox, connection and warm-up. */
+export const MANAGED_INBOX_ALL_IN_REPRICING = defineRepricedValue({
+    key: "managed_inbox.google_all_in_credits",
+    kind: "price",
+    slice: "S32",
+    decision: "3.1",
+    unit: "credits_per_inbox_per_month",
+    description: "A managed Google inbox, all-in: the mailbox plus its mailbox connection, warm-up included. Inbox placement is an optional add-on.",
+    before: 400,
+    after: SNAPSHOT_MANAGED_MAILBOX_CREDITS + SNAPSHOT_SENDING_MAILBOX_CREDITS,
+});
+/** A managed Google inbox's monthly credits, all-in, at the switch state (marketing and docs). */
+export function managedInboxAllInCredits(options = {}) {
+    return repricedValue(MANAGED_INBOX_ALL_IN_REPRICING, options);
+}
+/**
+ * S41 (decision 6.3): a provider call made with the customer's own API key
+ * (BYOK) pays a 0.05-credit platform fee, up from nothing. The vendor still
+ * bills the call itself. The seed and the generated snapshot carry the fee; it
+ * is 0 until the switch's instant. Standing permissions approved while BYOK was
+ * free (armed auto-runs, workflow triggers) pay it from then on inside the
+ * per-delivery ceiling they already carry (proposal P-67).
+ */
+export const BYOK_PLATFORM_FEE_REPRICING = defineRepricedValue({
+    key: "byok.platform_fee_credits",
+    kind: "price",
+    slice: "S41",
+    decision: "6.3",
+    unit: "credits per BYOK call",
+    description: "Platform fee on each provider call made with your own API key. The provider bills the call itself.",
+    before: 0,
+    after: SNAPSHOT_BYOK_PLATFORM_FEE_CREDITS,
+});
+// ---- S56 (L5.1, L5.2, L5.4): spend-safety defaults that TIGHTEN. ----------
+// Only the cuts are scheduled. Every other L5 change is a larger default or a
+// larger allowance and ships live on release (spec § 6.1): the L5.1 ceilings of
+// the $99-$999 plans and of grandfathered plans, and every L5.3 Copilot
+// allowance.
+/**
+ * L5.1 (decision L5.1; the free value and the rounding are PROPOSED P-54): the
+ * default credit ceiling of one unattended delivery is 10% of the plan's
+ * monthly credits, rounded half up. Integer arithmetic, because
+ * `229_885 * 0.1` is 22988.4999... in floating point and rounds the wrong way.
+ */
+export function tenthOfMonthlyCreditsRoundedHalfUp(monthlyCredits) {
+    return Math.floor((Math.round(monthlyCredits) + 5) / 10);
+}
+function snapshotMonthlyCredits(planKey) {
+    const credits = PRICING_PLAN_SNAPSHOT.find((plan) => plan.planKey === planKey)?.monthlyCredits;
+    if (typeof credits !== "number" || !(credits > 0)) {
+        throw new Error(`repricing: the pricing snapshot has no monthly credits for ${planKey}`);
+    }
+    return credits;
+}
+// The two plan sizes whose 10% default falls below the ceiling they read today
+// (the starter rung's 500 and the scale rung's 25,000). The new value follows
+// the plan's monthly credits in the pricing snapshot, so the volume bonus (S11)
+// moves it with the grant. `plan-band.test.ts` pins this list to exactly the
+// sizes whose target is below today's value.
+const DELIVERY_CEILING_CUTS = [
+    { band: "49", before: 500, plans: "the $49 plan" },
+    { band: "1999", before: 25_000, plans: "the $1,999 plan and legacy scale plans" },
+];
+export const S56_DELIVERY_CREDIT_CEILING_CUTS = DELIVERY_CEILING_CUTS.map(({ band, before, plans }) => defineRepricedValue({
+    key: `spend.${band}.default_delivery_credit_ceiling`,
+    kind: "limit",
+    slice: "S56",
+    decision: "L5.1",
+    unit: "credits_per_delivery",
+    description: `Default credit ceiling of one unattended workflow trigger delivery or table auto-run batch armed without max_credits, on ${plans}. An explicit max_credits always wins.`,
+    before,
+    after: tenthOfMonthlyCreditsRoundedHalfUp(snapshotMonthlyCredits(`oxygen_${band}`)),
+}));
+/**
+ * L5.2 (decision L5.2): the free plan gains a default daily runaway guard. Free
+ * had none, because the guard scales from a monthly grant free does not have,
+ * so the guard itself is the tightening: no bound before the instant.
+ */
+export const FREE_ORG_DAILY_GUARD_WARN_CREDITS = defineRepricedValue({
+    key: "spend.free.org_daily_guard_warn_credits",
+    kind: "limit",
+    slice: "S56",
+    decision: "L5.2",
+    unit: "credits_per_utc_day",
+    description: "Default daily spend guard on the free plan: managed spend past this in one UTC day raises a warning.",
+    before: null,
+    after: 1_000,
+});
+export const FREE_ORG_DAILY_GUARD_BLOCK_CREDITS = defineRepricedValue({
+    key: "spend.free.org_daily_guard_block_credits",
+    kind: "limit",
+    slice: "S56",
+    decision: "L5.2",
+    unit: "credits_per_utc_day",
+    description: "Default daily spend guard on the free plan: managed spend past this in one UTC day is refused, unless you set your own daily budget.",
+    before: null,
+    after: 5_000,
+});
+/**
+ * L5.4 (decision L5.4; the inference half is PROPOSED P-56): the default credit
+ * ceilings of one Agent run on the team and scale limits rungs, which the $999
+ * and $1,999 plans, grandfathered Team plans and legacy scale plans read. A
+ * customer can still approve a higher ceiling for a single run.
+ */
+export const S56_AGENT_RUN_LIMIT_CUTS = [
+    { tier: "team", plans: "the $999 plan and grandfathered Team plans", total: 5_000, inference: 2_500 },
+    { tier: "scale", plans: "the $1,999 plan and legacy scale plans", total: 10_000, inference: 5_000 },
+].flatMap(({ tier, plans, total, inference }) => [
+    defineRepricedValue({
+        key: `agents.${tier}.max_total_credits`,
+        kind: "limit",
+        slice: "S56",
+        decision: "L5.4",
+        unit: "credits_per_agent_run",
+        description: `Most credits one Agent run may use in total on ${plans}, unless you approve a higher ceiling for that run.`,
+        before: total,
+        after: 2_500,
+    }),
+    defineRepricedValue({
+        key: `agents.${tier}.max_inference_credits`,
+        kind: "limit",
+        slice: "S56",
+        decision: "L5.4 (P-56)",
+        unit: "credits_per_agent_run",
+        description: `Most credits one Agent run may spend on its own model calls on ${plans}.`,
+        before: inference,
+        after: 1_250,
+    }),
+]);
+/**
+ * S53 (decision L4.2, ratified 2026-09-26): a free workspace may schedule a
+ * workflow or Agent cron at most every 15 minutes, down from every minute. Paid
+ * plans keep every minute. A new schedule that fires closer together is refused
+ * with `cron_interval_below_plan_minimum`; one already armed keeps running at the
+ * 15-minute interval instead and is never deleted (proposal P-47).
+ * `resolveCronMinIntervalMinutes` in plan-limits.ts resolves it, and a test pins
+ * `after` to `PLAN_LIMITS.free.workflows.cronMinIntervalMinutes`.
+ */
+export const FREE_CRON_MIN_INTERVAL_REPRICING = defineRepricedValue({
+    key: "workflows.free.cron_min_interval_minutes",
+    kind: "limit",
+    slice: "S53",
+    decision: "L4.2",
+    unit: "minutes",
+    description: "Fastest cron schedule on the free plan. A faster new schedule is refused; one already armed runs at this interval instead.",
+    before: 1,
+    after: 15,
+});
+// ---- S42 (decision 4.4, bugs B2 and B3): person-reveal pricing. ----------
+// Apollo and Lusha person enrichment are priced by what the request reveals,
+// per record. The decreases ship live (Apollo email-only 100 → 12.5 and a
+// small Apollo bulk request); what rises waits for the switch: a Lusha phone
+// reveal, and pricing per contact or record where a request used to cost one
+// flat price whatever it held. `pricing-resolver.ts` (@oxygen/integrations)
+// holds a request at its old per-request price until the instant, and a test
+// there pins each `after` to the pricing seed in `cogs-rates.ts`.
+/** A Lusha person enrichment that reveals a phone number, per contact. */
+export const LUSHA_PHONE_REVEAL_CREDITS_REPRICING = defineRepricedValue({
+    key: "enrichment.lusha.person_enrich_phone_credits",
+    kind: "price",
+    slice: "S42",
+    decision: "4.4",
+    unit: "credits_per_contact",
+    description: "Lusha person enrichment that reveals a phone number (5 Lusha credits), per contact.",
+    before: 43.5,
+    after: 217.5,
+});
+/** A Lusha person enrichment that reveals an email and a phone number, per contact. */
+export const LUSHA_EMAIL_AND_PHONE_REVEAL_CREDITS_REPRICING = defineRepricedValue({
+    key: "enrichment.lusha.person_enrich_email_and_phone_credits",
+    kind: "price",
+    slice: "S42",
+    decision: "4.4",
+    unit: "credits_per_contact",
+    description: "Lusha person enrichment that reveals an email and a phone number (6 Lusha credits), per contact.",
+    before: 43.5,
+    after: 261,
+});
+/**
+ * Before the instant a Lusha or Apollo bulk person enrichment never costs more
+ * than its old flat price per request (43.5 and 100); from it on, it costs its
+ * per-record price times the contacts or records it holds.
+ */
+export const PERSON_REVEAL_PRICED_PER_RECORD_REPRICING = defineRepricedValue({
+    key: "enrichment.person_reveal_priced_per_record",
+    kind: "price",
+    slice: "S42",
+    decision: "4.4",
+    unit: "boolean",
+    description: "Lusha person enrichment and Apollo bulk person enrichment are priced per contact or record, not per request.",
+    before: false,
+    after: true,
+});
+export const S42_REVEAL_PRICE_RISES = [
+    LUSHA_PHONE_REVEAL_CREDITS_REPRICING,
+    LUSHA_EMAIL_AND_PHONE_REVEAL_CREDITS_REPRICING,
+    PERSON_REVEAL_PRICED_PER_RECORD_REPRICING,
+];
+// ---- S43 (decision 4.2): a LinkedIn URL at a flat price per URL found. ----
+// Until the instant, each lane of the LinkedIn-URL waterfall bills its own
+// price on every attempt, found or not (the managed rail lookup about 2, Icypeas
+// about 2.5). From it, the default chain bills a flat 5 credits only when it
+// finds a URL that passes the identity match (P-35), and a miss costs 0. The
+// price per hit rises, so the whole change waits for the switch. Lanes named
+// outside the default chain keep their own price, and a direct tool call keeps
+// its tool price (P-34). `pricing-resolver.ts` (@oxygen/integrations) applies
+// it; a test there pins the flat price to the pricing seed.
+/** Whether the LinkedIn-URL waterfall bills a flat price per URL found. */
+export const LINKEDIN_URL_FLAT_PRICE_REPRICING = defineRepricedValue({
+    key: "enrichment.linkedin_url_priced_per_found_url",
+    kind: "price",
+    slice: "S43",
+    decision: "4.2",
+    unit: "boolean",
+    description: `A LinkedIn URL costs a flat ${SNAPSHOT_LINKEDIN_URL_FOUND_CREDITS} credits when one is found that matches the person, and nothing when none is found, instead of each provider's price on every attempt.`,
+    before: false,
+    after: true,
+});
+/** True once a LinkedIn URL is priced per URL found (S43). */
+export function linkedinUrlFlatPriceInForce(options = {}) {
+    return repricedValue(LINKEDIN_URL_FLAT_PRICE_REPRICING, options);
+}
+/** The flat price of one LinkedIn URL found, in credits (the pricing seed's `enrichment.linkedin_url_found`). */
+export function linkedinUrlFoundCredits() {
+    return SNAPSHOT_LINKEDIN_URL_FOUND_CREDITS;
+}
+function snapshotByokEnabled(planKey) {
+    const plan = PRICING_PLAN_SNAPSHOT.find((row) => row.planKey === planKey);
+    if (!plan)
+        throw new Error(`repricing: the pricing snapshot has no plan ${planKey}`);
+    return plan.byokEnabled;
+}
+/**
+ * S22 (decision 2.7): bringing your own provider keys (BYOK) needs the $99 plan
+ * or above. The pricing seed and snapshot carry the new value (`oxygen_49`
+ * `byokEnabled: false`); `resolveBasePricingPlan` holds the $49 plan at the old
+ * value until the switch's instant. From the instant on, a key the workspace
+ * connected before it keeps working until the plan changes (P-20, proposed):
+ * `byokConnectionGrandfathered` in plan-capabilities.ts.
+ */
+export const OXYGEN_49_BYOK_REPRICING = defineRepricedValue({
+    key: "plans.oxygen_49.byok_enabled",
+    kind: "limit",
+    slice: "S22",
+    decision: "2.7",
+    unit: "boolean",
+    description: "Whether the $49 plan may connect your own provider API keys. From this date bringing your own keys needs the $99 plan or above; keys connected before it keep working until the plan changes.",
+    before: true,
+    after: snapshotByokEnabled("oxygen_49"),
+});
 /**
  * Every value the 2026-09 switch moves. Each dark slice appends its entries
  * here, so `oxygen limits show` can list them once a date is set and one test
@@ -223,10 +608,26 @@ export const S20_RESERVATION_PRICE_RISES = [
  * after it.
  */
 export const REPRICING_2026_09_SCHEDULE = [
+    TOPUP_RATE_REPRICING,
     ...storageCutEntries(),
     ...S20_RESERVATION_PRICE_RISES,
+    DELIVERABILITY_SEAT_REPRICING,
+    PLACEMENT_TEST_REPRICING,
+    MANAGED_MAILBOX_REPRICING,
+    MANAGED_INBOX_ALL_IN_REPRICING,
     EMAIL_MAILBOX_DAILY_CAP_MAXIMUM,
     EMAIL_MAILBOX_OLD_DEFAULT_DAILY_CAP,
+    AUTOMATION_STEP_CREDITS_REPRICING,
+    AUTOMATION_STEPS_COUNT_TOWARD_RUN_CAP_REPRICING,
+    BYOK_PLATFORM_FEE_REPRICING,
+    FREE_CRON_MIN_INTERVAL_REPRICING,
+    ...S56_DELIVERY_CREDIT_CEILING_CUTS,
+    FREE_ORG_DAILY_GUARD_WARN_CREDITS,
+    FREE_ORG_DAILY_GUARD_BLOCK_CREDITS,
+    ...S56_AGENT_RUN_LIMIT_CUTS,
+    ...S42_REVEAL_PRICE_RISES,
+    LINKEDIN_URL_FLAT_PRICE_REPRICING,
+    OXYGEN_49_BYOK_REPRICING,
 ];
 /** The schedule entry with this key, or undefined. */
 export function findRepricedValue(key, schedule = REPRICING_2026_09_SCHEDULE) {

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

@@ -0,0 +1,21 @@
+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;

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

@@ -0,0 +1,41 @@
+/**
+ * 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;
+}