@oxygen-agent/cli 1.987.20 → 1.1003.12

package/node_modules/@oxygen/shared/dist/otlp-log-sink.js

@@ -0,0 +1,213 @@
+const DEFAULT_BATCH_SIZE = 500;
+const DEFAULT_FLUSH_INTERVAL_MS = 2_000;
+const DEFAULT_MAX_QUEUE = 10_000;
+const EXPORT_TIMEOUT_MS = 10_000;
+const NO_TIMER_REPORT_WINDOW_MS = 60_000;
+const MAX_ERROR_BODY = 300;
+// OTLP severity numbers (logs data model): the base of each 4-value band.
+const SEVERITY_NUMBERS = { debug: 5, info: 9, warn: 13, error: 17 };
+// Set by log() on every record; they become the OTLP record's own fields rather
+// than attributes, so carrying them twice would just inflate every batch.
+const RECORD_FIELDS_NOT_ATTRIBUTES = new Set(["ts", "level", "msg"]);
+/**
+ * `k=v,k=v` — the same shape as `OTEL_EXPORTER_OTLP_HEADERS`, so an operator who
+ * knows the OTel variable can set ours without learning a second syntax. A pair
+ * with no `=`, or an empty key, is skipped rather than throwing: this is parsed
+ * at process start, and a malformed telemetry header must not stop a boot. The
+ * value keeps every `=` after the first (tokens contain them).
+ */
+export function parseOtlpHeaders(raw) {
+    const headers = {};
+    if (!raw)
+        return headers;
+    for (const pair of raw.split(",")) {
+        const separator = pair.indexOf("=");
+        if (separator <= 0)
+            continue;
+        const key = pair.slice(0, separator).trim();
+        const value = pair.slice(separator + 1).trim();
+        if (!key)
+            continue;
+        headers[key] = value;
+    }
+    return headers;
+}
+function toAnyValue(value) {
+    if (typeof value === "string")
+        return { stringValue: value };
+    if (typeof value === "boolean")
+        return { boolValue: value };
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return { stringValue: String(value) };
+        // OTLP/JSON encodes int64 as a STRING (proto3 JSON mapping); a bare number
+        // there is what makes a collector reject an otherwise valid record.
+        return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+    }
+    if (value === null || value === undefined)
+        return null;
+    try {
+        return { stringValue: JSON.stringify(value) ?? String(value) };
+    }
+    catch {
+        return { stringValue: "[unserializable]" };
+    }
+}
+function toAttributes(source, skip) {
+    const attributes = [];
+    for (const [key, value] of Object.entries(source)) {
+        if (skip?.has(key))
+            continue;
+        const anyValue = toAnyValue(value);
+        if (!anyValue)
+            continue;
+        attributes.push({ key, value: anyValue });
+    }
+    return attributes;
+}
+function timeUnixNano(ts) {
+    const parsed = typeof ts === "string" ? Date.parse(ts) : Number.NaN;
+    const millis = Number.isFinite(parsed) ? parsed : Date.now();
+    // Decimal string, not a number: nanoseconds since the epoch exceed 2^53.
+    return `${millis}000000`;
+}
+function toLogRecord(record) {
+    const level = typeof record.level === "string" && record.level in SEVERITY_NUMBERS
+        ? record.level
+        : "info";
+    return {
+        timeUnixNano: timeUnixNano(record.ts),
+        severityNumber: SEVERITY_NUMBERS[level],
+        severityText: level.toUpperCase(),
+        body: { stringValue: typeof record.msg === "string" ? record.msg : String(record.msg ?? "") },
+        attributes: toAttributes(record, RECORD_FIELDS_NOT_ATTRIBUTES),
+    };
+}
+export function createOtlpLogSink(options) {
+    const batchSize = options.batchSize && options.batchSize > 0 ? options.batchSize : DEFAULT_BATCH_SIZE;
+    const maxQueue = options.maxQueue && options.maxQueue > 0 ? options.maxQueue : DEFAULT_MAX_QUEUE;
+    const flushIntervalMs = options.flushIntervalMs === undefined
+        ? DEFAULT_FLUSH_INTERVAL_MS
+        : options.flushIntervalMs;
+    const doFetch = options.fetch ?? globalThis.fetch;
+    const reportWindowMs = flushIntervalMs > 0 ? flushIntervalMs : NO_TIMER_REPORT_WINDOW_MS;
+    // A null/undefined override is dropped rather than applied, so a caller that
+    // resolves its own environment and comes back empty-handed falls back to the
+    // default here instead of shipping records with no `deployment.environment`.
+    const resourceOverrides = Object.fromEntries(Object.entries(options.resource ?? {}).filter(([, value]) => value !== null && value !== undefined));
+    const resourceAttributes = toAttributes({
+        "service.name": options.serviceName,
+        "deployment.environment": process.env.OXYGEN_DEPLOY_ENV
+            ?? process.env.VERCEL_ENV
+            ?? process.env.NODE_ENV
+            ?? null,
+        ...resourceOverrides,
+    });
+    const queue = [];
+    let inFlight = null;
+    let stopped = false;
+    let lastReportAt = 0;
+    // Never through log(): this module IS the sink log() calls, so a log() here
+    // would enqueue its own failure and re-fail on the next flush forever. stderr
+    // is the one destination that cannot re-enter, and the write is guarded
+    // because a closed/full stderr must not throw into the flush path either.
+    const report = (fields) => {
+        const now = Date.now();
+        if (now - lastReportAt < reportWindowMs)
+            return;
+        lastReportAt = now;
+        try {
+            process.stderr.write(`${JSON.stringify({
+                level: "error",
+                msg: "otlp_log_sink.export_failed",
+                endpoint: options.endpoint,
+                ...fields,
+            })}\n`);
+        }
+        catch {
+            // A telemetry failure that cannot even be reported is still not a fault
+            // of the code being observed.
+        }
+    };
+    const sink = (record) => {
+        if (stopped)
+            return;
+        // Drop the OLDEST record and keep this one: under sustained backpressure the
+        // newest lines are the ones describing the incident being debugged.
+        while (queue.length >= maxQueue) {
+            queue.shift();
+        }
+        queue.push(record);
+    };
+    const flush = async () => {
+        if (inFlight)
+            return inFlight;
+        if (queue.length === 0)
+            return undefined;
+        const batch = queue.splice(0, batchSize);
+        const payload = JSON.stringify({
+            resourceLogs: [
+                {
+                    resource: { attributes: resourceAttributes },
+                    scopeLogs: [
+                        {
+                            scope: { name: "oxygen" },
+                            logRecords: batch.map(toLogRecord),
+                        },
+                    ],
+                },
+            ],
+        });
+        const run = (async () => {
+            try {
+                const response = await doFetch(options.endpoint, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", ...options.headers },
+                    body: payload,
+                    signal: AbortSignal.timeout(EXPORT_TIMEOUT_MS),
+                });
+                if (response.ok)
+                    return;
+                let body = "";
+                try {
+                    body = (await response.text()).slice(0, MAX_ERROR_BODY);
+                }
+                catch {
+                    // An unreadable body is no worse than a status-only report.
+                }
+                // The batch is gone deliberately: retrying into an unhealthy collector
+                // is how a telemetry path turns an ingest blip into memory pressure.
+                report({ status: response.status, dropped_events: batch.length, response_body: body });
+            }
+            catch (error) {
+                report({
+                    dropped_events: batch.length,
+                    error_message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        })();
+        inFlight = run.finally(() => {
+            inFlight = null;
+        });
+        return inFlight;
+    };
+    const timer = flushIntervalMs > 0
+        ? setInterval(() => {
+            void flush();
+        }, flushIntervalMs)
+        : null;
+    // Never hold the process open on the telemetry timer.
+    timer?.unref?.();
+    const stop = async () => {
+        stopped = true;
+        if (timer)
+            clearInterval(timer);
+        // Drain rather than flush once: a shutdown's final lines are usually the
+        // interesting ones, and one flush ships only the oldest `batchSize`.
+        while (queue.length > 0) {
+            await flush();
+        }
+        await inFlight;
+    };
+    return { sink, flush, stop };
+}

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

@@ -50,6 +50,7 @@ export const PLAN_GATED_CAPABILITIES = [
  * `required_plan_tiers` in tool-access, which the resolver consults separately.
  */
 export const PLAN_GATE_QUALIFYING_TIERS = [
+    "oxygen",
     "starter",
     "pro",
     "team",

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

@@ -185,14 +185,14 @@ export declare const PLAN_LIMITS: {
             readonly maxDirectCsvBodyBytes: 10000000;
         };
         readonly agents: {
-            readonly maxTotalCredits: 2500;
-            readonly maxInferenceCredits: 1500;
+            readonly maxTotalCredits: 250;
+            readonly maxInferenceCredits: 150;
             readonly maxUpstreamCostUsd: 10;
             readonly maxUpstreamCostUsdByok: 10;
         };
         readonly copilot: {
-            readonly maxSessionBudgetCredits: 5000;
-            readonly defaultPerTurnCreditCeiling: 1500;
+            readonly maxSessionBudgetCredits: 500;
+            readonly defaultPerTurnCreditCeiling: 150;
         };
         readonly signals: {
             readonly maxEvents: 100;
@@ -295,14 +295,14 @@ export declare const PLAN_LIMITS: {
             readonly maxDirectCsvBodyBytes: 10000000;
         };
         readonly agents: {
-            readonly maxTotalCredits: 10000;
-            readonly maxInferenceCredits: 5000;
+            readonly maxTotalCredits: 1000;
+            readonly maxInferenceCredits: 500;
             readonly maxUpstreamCostUsd: 10;
             readonly maxUpstreamCostUsdByok: 250;
         };
         readonly copilot: {
-            readonly maxSessionBudgetCredits: 5000;
-            readonly defaultPerTurnCreditCeiling: 1500;
+            readonly maxSessionBudgetCredits: 500;
+            readonly defaultPerTurnCreditCeiling: 150;
         };
         readonly signals: {
             readonly maxEvents: 200;
@@ -405,14 +405,14 @@ export declare const PLAN_LIMITS: {
             readonly maxDirectCsvBodyBytes: 10000000;
         };
         readonly agents: {
-            readonly maxTotalCredits: 25000;
-            readonly maxInferenceCredits: 12500;
+            readonly maxTotalCredits: 2500;
+            readonly maxInferenceCredits: 1250;
             readonly maxUpstreamCostUsd: 25;
             readonly maxUpstreamCostUsdByok: 250;
         };
         readonly copilot: {
-            readonly maxSessionBudgetCredits: 10000;
-            readonly defaultPerTurnCreditCeiling: 2500;
+            readonly maxSessionBudgetCredits: 1000;
+            readonly defaultPerTurnCreditCeiling: 250;
         };
         readonly signals: {
             readonly maxEvents: 200;
@@ -515,14 +515,14 @@ export declare const PLAN_LIMITS: {
             readonly maxDirectCsvBodyBytes: 10000000;
         };
         readonly agents: {
-            readonly maxTotalCredits: 50000;
-            readonly maxInferenceCredits: 25000;
+            readonly maxTotalCredits: 5000;
+            readonly maxInferenceCredits: 2500;
             readonly maxUpstreamCostUsd: 50;
             readonly maxUpstreamCostUsdByok: 250;
         };
         readonly copilot: {
-            readonly maxSessionBudgetCredits: 20000;
-            readonly defaultPerTurnCreditCeiling: 5000;
+            readonly maxSessionBudgetCredits: 2000;
+            readonly defaultPerTurnCreditCeiling: 500;
         };
         readonly signals: {
             readonly maxEvents: 200;
@@ -625,14 +625,14 @@ export declare const PLAN_LIMITS: {
             readonly maxDirectCsvBodyBytes: 10000000;
         };
         readonly agents: {
-            readonly maxTotalCredits: 100000;
-            readonly maxInferenceCredits: 50000;
+            readonly maxTotalCredits: 10000;
+            readonly maxInferenceCredits: 5000;
             readonly maxUpstreamCostUsd: 100;
             readonly maxUpstreamCostUsdByok: 250;
         };
         readonly copilot: {
-            readonly maxSessionBudgetCredits: 50000;
-            readonly defaultPerTurnCreditCeiling: 10000;
+            readonly maxSessionBudgetCredits: 5000;
+            readonly defaultPerTurnCreditCeiling: 1000;
         };
         readonly signals: {
             readonly maxEvents: 200;
@@ -645,8 +645,9 @@ export declare const PLAN_LIMITS: {
 };
 /**
  * Map a raw plan-tier string (subscription `tier`, metadata tier, legacy plan
- * key like `growth_250`) onto its enforcement rung. Unknown/absent tiers land
- * on the unentitled "free" rung; enterprise shares "scale".
+ * key like `growth_250`, or an Oxygen rung key like `oxygen_499`) onto its
+ * enforcement rung. Unknown/absent tiers land on the unentitled "free" rung;
+ * enterprise shares "scale".
  */
 export declare function limitsTierForPlanTier(tier: string | null | undefined): LimitsTier;
 export declare function planLimitsForTier(tier: LimitsTier): PlanLimits;

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

@@ -70,8 +70,8 @@ export const PLAN_LIMITS = {
         // is bounded by its balance, not by these. The intent is only that no single
         // run can silently eat a first impression.
         agents: {
-            maxTotalCredits: 2_500,
-            maxInferenceCredits: 1_500,
+            maxTotalCredits: 250,
+            maxInferenceCredits: 150,
             maxUpstreamCostUsd: 10,
             maxUpstreamCostUsdByok: 10,
         },
@@ -80,7 +80,7 @@ export const PLAN_LIMITS = {
         // path over the CLI must be able to complete one real session on the base
         // grant alone. Lowering this would re-create the dead-on-arrival Copilot the
         // split grant exists to prevent.
-        copilot: { maxSessionBudgetCredits: 5_000, defaultPerTurnCreditCeiling: 1_500 },
+        copilot: { maxSessionBudgetCredits: 500, defaultPerTurnCreditCeiling: 150 },
         signals: { maxEvents: 100, maxWindowDays: 30 },
         tableActions: { maxActionsPerRun: 10 },
     },
@@ -108,12 +108,12 @@ export const PLAN_LIMITS = {
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
-            maxTotalCredits: 10_000,
-            maxInferenceCredits: 5_000,
+            maxTotalCredits: 1_000,
+            maxInferenceCredits: 500,
             maxUpstreamCostUsd: 10,
             maxUpstreamCostUsdByok: 250,
         },
-        copilot: { maxSessionBudgetCredits: 5_000, defaultPerTurnCreditCeiling: 1_500 },
+        copilot: { maxSessionBudgetCredits: 500, defaultPerTurnCreditCeiling: 150 },
         signals: { maxEvents: 200, maxWindowDays: 90 },
         tableActions: { maxActionsPerRun: 25 },
     },
@@ -141,12 +141,12 @@ export const PLAN_LIMITS = {
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
-            maxTotalCredits: 25_000,
-            maxInferenceCredits: 12_500,
+            maxTotalCredits: 2_500,
+            maxInferenceCredits: 1_250,
             maxUpstreamCostUsd: 25,
             maxUpstreamCostUsdByok: 250,
         },
-        copilot: { maxSessionBudgetCredits: 10_000, defaultPerTurnCreditCeiling: 2_500 },
+        copilot: { maxSessionBudgetCredits: 1_000, defaultPerTurnCreditCeiling: 250 },
         signals: { maxEvents: 200, maxWindowDays: 180 },
         tableActions: { maxActionsPerRun: 25 },
     },
@@ -174,12 +174,12 @@ export const PLAN_LIMITS = {
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
-            maxTotalCredits: 50_000,
-            maxInferenceCredits: 25_000,
+            maxTotalCredits: 5_000,
+            maxInferenceCredits: 2_500,
             maxUpstreamCostUsd: 50,
             maxUpstreamCostUsdByok: 250,
         },
-        copilot: { maxSessionBudgetCredits: 20_000, defaultPerTurnCreditCeiling: 5_000 },
+        copilot: { maxSessionBudgetCredits: 2_000, defaultPerTurnCreditCeiling: 500 },
         signals: { maxEvents: 200, maxWindowDays: 365 },
         tableActions: { maxActionsPerRun: 25 },
     },
@@ -207,27 +207,54 @@ export const PLAN_LIMITS = {
             maxDirectCsvBodyBytes: 10_000_000,
         },
         agents: {
-            maxTotalCredits: 100_000,
-            maxInferenceCredits: 50_000,
+            maxTotalCredits: 10_000,
+            maxInferenceCredits: 5_000,
             maxUpstreamCostUsd: 100,
             maxUpstreamCostUsdByok: 250,
         },
-        copilot: { maxSessionBudgetCredits: 50_000, defaultPerTurnCreditCeiling: 10_000 },
+        copilot: { maxSessionBudgetCredits: 5_000, defaultPerTurnCreditCeiling: 1_000 },
         signals: { maxEvents: 200, maxWindowDays: 365 },
         tableActions: { maxActionsPerRun: 25 },
     },
 };
+/**
+ * Which enforcement rung a rung of the six-rung Oxygen plan lands on.
+ *
+ * The rungs share one `oxygen` tier, so the ladder has to be re-derived from
+ * price. Deliberately scoped to `oxygen` rather than applied to every plan: a
+ * blanket price band would regress the grandfathered plans, demoting `pro_149`
+ * ($149) to "starter" and `team_399` ($399) to "pro".
+ */
+function oxygenRungLimitsTier(monthlyPriceCents) {
+    if (monthlyPriceCents === null)
+        return "starter";
+    // Thresholds track the ladder these rungs replaced, so nobody's enforcement
+    // rung moves for a price they were already paying: Starter was $99, Pro $249,
+    // Team $749. A rung sits on the rung of the old plan at or below its price —
+    // $499 is below the old Team, so it enforces as "pro".
+    if (monthlyPriceCents >= 199_900)
+        return "scale";
+    if (monthlyPriceCents >= 99_900)
+        return "team";
+    if (monthlyPriceCents >= 19_900)
+        return "pro";
+    return "starter";
+}
 /**
  * Map a raw plan-tier string (subscription `tier`, metadata tier, legacy plan
- * key like `growth_250`) onto its enforcement rung. Unknown/absent tiers land
- * on the unentitled "free" rung; enterprise shares "scale".
+ * key like `growth_250`, or an Oxygen rung key like `oxygen_499`) onto its
+ * enforcement rung. Unknown/absent tiers land on the unentitled "free" rung;
+ * enterprise shares "scale".
  */
 export function limitsTierForPlanTier(tier) {
-    const base = resolveBasePricingPlan(tier)?.tier;
+    const plan = resolveBasePricingPlan(tier);
+    const base = plan?.tier;
     if (!base || base === "free")
         return "free";
     if (base === "enterprise")
         return "scale";
+    if (base === "oxygen")
+        return oxygenRungLimitsTier(plan?.monthlyPriceCents ?? null);
     return base;
 }
 export function planLimitsForTier(tier) {

package/node_modules/@oxygen/shared/dist/pricing-sheet.d.ts

@@ -3,7 +3,7 @@
  * page's "what credits buy" table, the pricing calculator, and docs.
  *
  * Pricing Model 2.0 (founder-ratified 2026-07-14): ONE credit pool pays for
- * everything; 1 USD = 1,000 credits.
+ * everything; 1 USD = 100 credits.
  *
  * THIS FILE NO LONGER DECLARES PRICES. It used to carry hand-copied literals
  * under a comment asking the next person to remember to update them — which is
@@ -36,9 +36,9 @@
  */
 export { creditsToUsd, usdToCredits } from "./pricing-snapshot.generated.js";
 export declare const PRICING_SHEET_VERIFIED = "2026-07";
-export declare const PRICING_CREDITS_PER_USD = 1000;
-/** On-demand top-up price per 1,000 credits (USD); subscriptions pay $1.00. */
-export declare const TOPUP_USD_PER_1K = 1.25;
+export declare const PRICING_CREDITS_PER_USD = 100;
+/** On-demand top-up price per 100 credits (USD); subscriptions pay $1.00. */
+export declare const TOPUP_USD_PER_100 = 1.25;
 export declare const SENDING_SEAT_USD_CENTS: {
     readonly linkedin: 3000;
     readonly whatsapp: 3000;
@@ -47,7 +47,7 @@ export declare const SENDING_SEAT_USD_CENTS: {
 };
 export declare const MANAGED_INBOX_USD_CENTS = 400;
 export declare const SENDING_DOMAIN_USD_CENTS = 1250;
-export declare const SUBSCRIPTION_USD_PER_1K = 1;
+export declare const SUBSCRIPTION_USD_PER_100 = 1;
 /**
  * AI column runs, honest 5× of modeled tier COGS.
  *
@@ -58,28 +58,35 @@ export declare const SUBSCRIPTION_USD_PER_1K = 1;
  * quietly mispricing the page.
  */
 export declare const AI_COLUMN_CREDITS: {
-    readonly low: 15;
-    readonly medium: 75;
-    readonly high: 250;
+    readonly low: 1.5;
+    readonly medium: 7.5;
+    readonly high: 25;
 };
 /**
- * Web-search grounding, billed per SEARCH on top of the model — not a flat adder.
+ * Web-search grounding, billed per PROVIDER CALL on top of the model — not a flat
+ * adder.
  *
- * This replaces `AI_COLUMN_WEB_SEARCH_SURCHARGE_CREDITS = 25`, which was a real
- * under-quote on a public pricing surface: it was a leftover from the bundled
- * `*_with_web_search` model tiers that were removed when grounding moved onto
- * native providers, and the billing path never read it. Actual customer price is
- * the managed provider's own per-search charge (cogs-rates.ts): exa 35, parallel
- * 5, firecrawl 80 at the default 5 results. The default column runs exa primary
- * with parallel as its one fallback (WEB_SEARCH_ENGINES), so a row costs 35 when
- * the primary answers and reserves 40 for the case where both lanes fire.
+ * This replaced `AI_COLUMN_WEB_SEARCH_SURCHARGE_CREDITS = 25`, a real under-quote on
+ * a public surface: a leftover from the bundled `*_with_web_search` model tiers that
+ * were removed when grounding moved onto native providers, which the billing path
+ * never read.
  *
- * Resolver-derived like AI_COLUMN_CREDITS above, and pinned by the same test.
+ * The figures below describe the DEFAULT research column, which since D53 discovers
+ * then reads: `serper.search` (0.5) finds the URLs, then one additive
+ * `exa.contents` read (0.5) turns the top result's ~160-char SERP teaser into real
+ * page text. So a typical row spends 1 and a preview reserves 4.5, because the
+ * ceiling must also cover the `exa.search` fallback (3.5) firing when serper finds
+ * nothing. The read carries no fallback of its own — a read miss leaves the row
+ * grounded on the snippets it already has.
+ *
+ * Both numbers are RESOLVER-DERIVED and pinned by pricing-sheet-conformance.test.ts
+ * against the shipped default, so a re-price or a lane change fails a test rather
+ * than quietly mispricing this page. Do not hand-edit them.
  */
-export declare const AI_COLUMN_WEB_SEARCH_TYPICAL_CREDITS = 35;
-export declare const AI_COLUMN_WEB_SEARCH_RESERVED_CREDITS = 40;
+export declare const AI_COLUMN_WEB_SEARCH_TYPICAL_CREDITS = 1;
+export declare const AI_COLUMN_WEB_SEARCH_RESERVED_CREDITS = 4.5;
 /** Workflow/automation actions (steps, tool calls, row writes) — capacity guard. */
-export declare const AUTOMATION_ACTION_CREDITS = 0.01;
+export declare const AUTOMATION_ACTION_CREDITS = 0.001;
 /**
  * Managed email inboxes: founder-ratified flat price (2026-07-25), superseding
  * the earlier dynamic vendor-COGS × 1.25 range. Kept as an object (min/typical/max
@@ -88,9 +95,9 @@ export declare const AUTOMATION_ACTION_CREDITS = 0.01;
  */
 export declare const MANAGED_INBOX_MARKUP = 1.25;
 export declare const MANAGED_INBOX_CREDITS_PER_MONTH: {
-    readonly min: 3000;
-    readonly typical: 3000;
-    readonly max: 3000;
+    readonly min: 300;
+    readonly typical: 300;
+    readonly max: 300;
 };
 /**
  * VOICE (the call channel). Marked up 5×, not the 1.25× infra rule the inbox and
@@ -106,12 +113,12 @@ export declare const MANAGED_INBOX_CREDITS_PER_MONTH: {
  * Costing only the outbound leg undercharges every call by 29%.
  */
 export declare const VOICE_MARKUP = 5;
-export declare const VOICE_NUMBER_CREDITS_PER_MONTH = 5000;
-export declare const VOICE_CREDITS_PER_MINUTE = 90;
-export declare const VOICE_CREDITS_PER_AMD_CALL = 38;
+export declare const VOICE_NUMBER_CREDITS_PER_MONTH = 500;
+export declare const VOICE_CREDITS_PER_MINUTE = 9;
+export declare const VOICE_CREDITS_PER_AMD_CALL = 3.8;
 /** Managed domains: registrar at-cost × 1.25 (≈ a $10.44 .com → ~13,050 credits/yr). */
 export declare const MANAGED_DOMAIN_MARKUP = 1.25;
-export declare const MANAGED_DOMAIN_CREDITS_PER_YEAR_TYPICAL = 13050;
+export declare const MANAGED_DOMAIN_CREDITS_PER_YEAR_TYPICAL = 1305;
 /**
  * Inbox deliverability (EmailGuard placement seat). A flat monthly price per
  * SUBSCRIBED inbox covering continuous deliverability monitoring (blacklist,
@@ -126,9 +133,9 @@ export declare const MANAGED_DOMAIN_CREDITS_PER_YEAR_TYPICAL = 13050;
  * revenue — a ~73% margin — and everything past them bills
  * PLACEMENT_TEST_OVERAGE_CREDITS. Orgs on their own EmailGuard key (BYOK) pay 0.
  */
-export declare const DELIVERABILITY_SEAT_CREDITS_PER_MONTH = 1000;
+export declare const DELIVERABILITY_SEAT_CREDITS_PER_MONTH = 100;
 export declare const DELIVERABILITY_INCLUDED_TESTS_PER_INBOX = 2;
-export declare const PLACEMENT_TEST_OVERAGE_CREDITS = 166;
+export declare const PLACEMENT_TEST_OVERAGE_CREDITS = 16.6;
 /**
  * LinkedIn accounts: founder decision (2026-07-25) — a PURE seat model. The
  * flat monthly connection fee per connected account is the WHOLE LinkedIn
@@ -136,7 +143,7 @@ export declare const PLACEMENT_TEST_OVERAGE_CREDITS = 166;
  * stay 0 too — but a connected WhatsApp NUMBER carries its own monthly
  * connection fee, see WHATSAPP_ACCOUNT_CREDITS_PER_MONTH.
  */
-export declare const LINKEDIN_ACCOUNT_CREDITS_PER_MONTH = 10000;
+export declare const LINKEDIN_ACCOUNT_CREDITS_PER_MONTH = 1000;
 export declare const LINKEDIN_ACTION_CREDITS: {
     readonly visit_profile: 0;
     readonly invite: 0;
@@ -153,9 +160,9 @@ export declare const LINKEDIN_TYPICAL_ACTIONS_CREDITS_PER_MONTH = 0;
  * part-way through a month still bills the full cycle. WhatsApp message sends
  * themselves remain 0 credits.
  */
-export declare const WHATSAPP_ACCOUNT_CREDITS_PER_MONTH = 10000;
+export declare const WHATSAPP_ACCOUNT_CREDITS_PER_MONTH = 1000;
 /** Dedicated egress IP add-on. */
-export declare const EGRESS_IP_CREDITS_PER_MONTH = 25000;
+export declare const EGRESS_IP_CREDITS_PER_MONTH = 2500;
 /**
  * Email + WhatsApp sends cost nothing per message — the pool pays for inboxes and
  * connected accounts, not for sends.
@@ -170,13 +177,13 @@ export declare const SEND_CREDITS = 0;
  * pricing seed.
  */
 export declare const ENRICHMENT_CREDITS: {
-    readonly email_verify: 2.245;
-    readonly email_find_typical: 85;
-    readonly phone_find_typical: 990;
-    readonly company_enrich_typical: 99;
-    readonly web_search: 5;
-    readonly page_scrape: 40;
-    readonly linkedin_profile_scrape: 10;
+    readonly email_verify: 0.225;
+    readonly email_find_typical: 8.5;
+    readonly phone_find_typical: 99;
+    readonly company_enrich_typical: 9.9;
+    readonly web_search: 0.5;
+    readonly page_scrape: 4;
+    readonly linkedin_profile_scrape: 1;
 };
 /** Editable calculator default: blended credits per fully-enriched row. */
-export declare const ENRICHMENT_CREDITS_PER_ROW_TYPICAL = 100;
+export declare const ENRICHMENT_CREDITS_PER_ROW_TYPICAL = 10;