@oxygen-agent/cli 1.377.3 → 1.591.1

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

@@ -30,6 +30,108 @@ export function creditTopupUsdCents(credits) {
 // from the same credit pool at a flat capacity-guard rate — the old separate
 // monthly action allowance + USD overage meter economy is retired (2026-07-14).
 export const AUTOMATION_ACTION_CREDITS = 0.01;
+// ---------------------------------------------------------------------------
+// FIXED (committed) credit commitments — recurring per-resource monthly charges
+// ---------------------------------------------------------------------------
+//
+// Credit consumption splits in two (founder decision 2026-07-25):
+//   FIXED    — recurring per-resource monthly charges known in advance. These are
+//              BLOCKED out of the balance so flexible spend cannot eat them, and
+//              each resource rolls on its OWN monthly anchor (see billing-anchors.ts).
+//   FLEXIBLE — everything drawn ad hoc: enrichment, AI columns, automation
+//              actions, copilot inference.
+//
+// The ledger/enforcement side lives in @oxygen/integrations (credit-commitments.ts);
+// this module owns only the ratified prices and the lifecycle constants, because
+// control-db and the worker both need them and neither may import the other.
+//
+// PRICE SOURCES DIFFER BY KIND ON PURPOSE:
+//   - sending_mailbox and managed_mailbox are ratified HERE (flat, code-signed).
+//   - mailbox_warmup and deliverability_unit are ratified in @oxygen/control-db
+//     and have live readers + billers in @oxygen/integrations. They stay null
+//     HERE because importing control-db into shared would invert the package
+//     graph; this is ownership routing, not an unsigned-price signal.
+/** Kinds of resource that carry a fixed monthly credit commitment. */
+export const CREDIT_COMMITMENT_KINDS = [
+    "sending_mailbox",
+    "managed_mailbox",
+    "mailbox_warmup",
+    "deliverability_unit",
+    "linkedin_account",
+    "whatsapp_account",
+];
+/**
+ * Sequencer platform fee per CONNECTED SENDING MAILBOX per month, in credits
+ * ($1.00). Charged on EVERY mailbox wired to the sequencer — BYOK/self-connected
+ * Gmail and Microsoft inboxes included — and it STACKS on Oxygen-sold mailboxes,
+ * which additionally pay their own mailbox/warmup/placement lines.
+ */
+export const SENDING_MAILBOX_MONTHLY_CREDITS = 1_000;
+/**
+ * Oxygen-sold managed mailbox per month, in credits ($3.00). Flat, superseding
+ * the dynamic vendor-COGS x 1.25 quote for the recurring mailbox line.
+ */
+export const MANAGED_MAILBOX_MONTHLY_CREDITS = 3_000;
+/**
+ * Grace window after a commitment goes past_due before the owning subsystem may
+ * suspend the resource. Notify -> pause -> lapse; never auto-cancel. Aligned with
+ * the subscription entitlement grace so a customer never hits two different
+ * clocks for the same missed payment.
+ */
+export const COMMITMENT_PAST_DUE_GRACE_DAYS = 14;
+/**
+ * Reconnect window in which an ENDED commitment resumes instead of starting a new
+ * one. The single most important anti-double-charge rule: a Unipile re-auth, a
+ * mailbox re-import, or a reconciler blip must not re-charge a full month. Past
+ * this window a reconnect is treated as genuinely new and gets a fresh anchor,
+ * so a long-dead row can never resurrect and bill a stale period.
+ */
+export const COMMITMENT_RESUME_WINDOW_MS = 24 * 60 * 60 * 1000;
+/**
+ * Maximum periods one commitment may catch up in a single sweep tick. A worker
+ * outage (or a resurrected row) must never drain a wallet in one lump: past this
+ * many overdue periods the biller skips forward, stamps metadata.skipped_periods,
+ * and logs. Fail closed TOWARD the customer.
+ */
+export const COMMITMENT_MAX_CATCHUP_PERIODS = 3;
+/**
+ * Free month granted to resources that already existed when commitments went
+ * live. Combined with CREDIT_COMMITMENT_EPOCH_AT (which pins their anchor to
+ * go-live rather than their original created_at), this guarantees no existing
+ * customer is charged for infrastructure that was free when they connected it.
+ */
+export const COMMITMENT_GRACE_DAYS = 30;
+/**
+ * Flat ratified monthly price for a commitment kind, in credits — or null when
+ * the price is not owned HERE (warmup and deliverability are ratified in
+ * @oxygen/control-db; their callers use the integrations readers).
+ *
+ * Returning null is the fail-closed signal: an unpriced kind creates NO
+ * commitment row rather than a zero-credit one, matching the
+ * InboxPricingUnsignedError / WarmupPricingUnsignedError doctrine.
+ */
+export function ratifiedCommitmentCredits(kind) {
+    switch (kind) {
+        case "sending_mailbox":
+            return SENDING_MAILBOX_MONTHLY_CREDITS;
+        case "managed_mailbox":
+            return MANAGED_MAILBOX_MONTHLY_CREDITS;
+        // Ratified in @oxygen/control-db (MAILBOX_WARMUP_MONTHLY_CREDITS /
+        // DELIVERABILITY_UNIT_MONTHLY_CREDITS) since 2026-07-29, alongside the seat
+        // prices below. @oxygen/shared cannot import control-db, so these still
+        // resolve through their own readers in @oxygen/integrations — null here
+        // means "not mine to answer", not "unpriced".
+        case "mailbox_warmup":
+        case "deliverability_unit":
+            return null;
+        // Signed in control-db (LINKEDIN_ACCOUNT_MONTHLY_CREDITS /
+        // WHATSAPP_ACCOUNT_MONTHLY_CREDITS) — control-db cannot import @oxygen/shared,
+        // so the constants live there and the caller passes them.
+        case "linkedin_account":
+        case "whatsapp_account":
+            return null;
+    }
+}
 export const CREDIT_TOPUP_PACKS = [
     { id: "10", usdCents: 1_000, credits: 8_000 },
     { id: "25", usdCents: 2_500, credits: 20_000 },
@@ -55,24 +157,27 @@ export const TRIAL_CREDIT_GRANT = 20_000;
 export const WALKTHROUGH_COMPLETION_BONUS_CREDITS = 1_000;
 export const WALKTHROUGH_SCRAPE_MAX_CREDITS = 2_000;
 export const BASE_PRICING_PLANS = {
+    // Fully retired as a distribution surface (2026-07-22; entry is the
+    // card-required Starter trial). The tier survives only as the unentitled
+    // fallback for churned / never-subscribed orgs: zero monthly credits means
+    // ensureCurrentPlanCreditGrant short-circuits — no monthly minting AND no
+    // rollover-cap claw-back of leftover balances, which stay spendable.
     free: {
         tier: "free",
         name: "Free",
         monthlyPriceCents: 0,
-        monthlyCredits: 10_000,
+        monthlyCredits: 0,
         weeklyCreditsLimit: null,
-        rolloverCap: 10_000,
+        rolloverCap: null,
         monthlyAutomationActions: null,
         automationOverageCentsPerMillion: null,
         automationOverageEnabledDefault: false,
         byokEnabled: false,
-        description: "Get $10 in credits on us every month — try OXYGEN with managed email, phone enrichment, and AI credits.",
-        ctaLabel: "Start free",
+        description: "No active plan. Start a 7-day Starter trial to use OXYGEN — existing credit balances remain spendable.",
+        ctaLabel: "Start trial",
         features: [
-            "$10 in credits every month",
-            "All integrations",
-            "Workflows",
-            "No card required",
+            "Existing credits stay spendable",
+            "Read access to your workspace",
         ],
     },
     starter: {
@@ -428,6 +533,78 @@ export function getCurrentBillingCycleKey(date = new Date()) {
     const month = String(date.getUTCMonth() + 1).padStart(2, "0");
     return `${year}-${month}`;
 }
+/**
+ * A monthly Stripe period runs 28-31 days; 35 leaves slack for a proration or a
+ * billing-anchor shift without admitting a quarterly or annual period.
+ */
+export const CREDIT_CYCLE_MAX_PERIOD_DAYS = 35;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function startOfUtcMonth(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1));
+}
+function startOfFollowingUtcMonth(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1));
+}
+function formatUtcMonth(date) {
+    return date.toLocaleDateString("en-US", {
+        month: "long",
+        year: "numeric",
+        timeZone: "UTC",
+    });
+}
+function formatUtcDay(date) {
+    return date.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        timeZone: "UTC",
+    });
+}
+/**
+ * The window the credit-allowance bar measures: "this month's credits", resolved
+ * to the boundary at which the plan's grant actually renews.
+ *
+ * A Stripe-managed monthly subscription renews on its own period boundary, so
+ * that is the honest cycle for it. Everything else — off-Stripe custom plans,
+ * the free tier, and any non-monthly Stripe period — renews by CALENDAR month,
+ * which is the same boundary already used by getCurrentBillingCycleKey(),
+ * getCurrentFreeTierCycleKey(), the shared-billing workspace cap, and the
+ * automation-actions meter. The fallback is therefore consistent with every
+ * other monthly concept in the product rather than an invention.
+ *
+ * The length guard cuts BOTH ways deliberately. `now - start <= 35d` rejects a
+ * stale period a webhook never advanced; `end - start <= 35d` rejects a genuine
+ * annual subscription, which would otherwise pass the first check on day 3 and
+ * render a 365-day "month".
+ */
+export function resolveCreditCycleWindow(input) {
+    const now = input.now ?? new Date();
+    const subscription = input.subscription;
+    const start = subscription?.currentPeriodStart ?? null;
+    const end = subscription?.currentPeriodEnd ?? null;
+    const usesPeriod = subscription != null
+        && !subscription.offStripe
+        && start != null
+        && start.getTime() <= now.getTime()
+        && now.getTime() - start.getTime() <= CREDIT_CYCLE_MAX_PERIOD_DAYS * MS_PER_DAY
+        && (end == null
+            || end.getTime() - start.getTime() <= CREDIT_CYCLE_MAX_PERIOD_DAYS * MS_PER_DAY);
+    if (usesPeriod && start) {
+        const periodEnd = end ?? new Date(start.getTime() + 31 * MS_PER_DAY);
+        return {
+            start,
+            end: periodEnd,
+            source: "subscription_period",
+            label: `${formatUtcDay(start)} – ${formatUtcDay(periodEnd)}`,
+        };
+    }
+    const monthStart = startOfUtcMonth(now);
+    return {
+        start: monthStart,
+        end: startOfFollowingUtcMonth(now),
+        source: "calendar_month",
+        label: formatUtcMonth(monthStart),
+    };
+}
 export function evaluateWeeklyQuota(usedCredits, requestedCredits, weeklyCreditsLimit) {
     const projectedCredits = usedCredits + requestedCredits;
     return {

package/node_modules/@oxygen/shared/dist/call-outcomes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Classifying how a dial ended, for the power dialer.
+ *
+ * This exists because the BROWSER CANNOT TELL. The dial path bridges the rep's
+ * leg to Twilio immediately and then `<Dial>` rings the lead, so the softphone
+ * reports "on call" while the phone is still ringing. A 25-second call that was
+ * never answered looks exactly like a 25-second conversation from the client's
+ * side. Only the carrier knows, via `DialCallStatus` and answering-machine
+ * detection, and both arrive server-side on the status webhook.
+ *
+ * So the rule is: the power dialer advances on what the SERVER says happened,
+ * never on a client-side timer.
+ */
+/** Mirrors tenant-db CALL_STATUSES. Kept as strings so shared stays dependency-free. */
+export type CallOutcomeStatus = "queued" | "ringing" | "in_progress" | "completed" | "failed" | "no_answer" | "busy" | "canceled" | "refused";
+export type CallOutcomeAnsweredBy = "human" | "machine_start" | "machine_end_beep" | "machine_end_silence" | "machine_end_other" | "fax" | "unknown";
+export type CallOutcome = {
+    status: CallOutcomeStatus | null;
+    answeredBy: CallOutcomeAnsweredBy | null;
+    /** Set when a guardrail refused the dial. */
+    refusedReason: string | null;
+};
+export type DialVerdict = 
+/** A person picked up. Stop the queue — the rep is in a conversation. */
+{
+    kind: "human";
+}
+/** Nobody, or a machine. Safe to auto-disposition and move on. */
+ | {
+    kind: "auto_advance";
+    disposition: "no_answer" | "voicemail" | "busy" | "failed";
+}
+/** A guardrail said no. Advancing would burn the queue against a standing block. */
+ | {
+    kind: "refused";
+    reason: string;
+}
+/** Not settled yet — poll again, and default to stopping if it never settles. */
+ | {
+    kind: "pending";
+};
+/**
+ * What should the dialer do next?
+ *
+ * Biased toward STOPPING. Auto-advancing past a live human is the worst failure
+ * this component has — it hangs up on a prospect who answered — so anything
+ * ambiguous returns `pending`, and a caller that runs out of patience must stop
+ * rather than advance.
+ */
+export declare function classifyDialOutcome(outcome: CallOutcome): DialVerdict;
+/**
+ * Should a refusal stop the whole session rather than skip one lead?
+ *
+ * A suppressed contact or a bad calling window is specific to that lead — skip
+ * it. An exhausted daily cap, an unhealthy pool, or an empty credit balance
+ * refuses everyone, so continuing would march through the entire queue marking
+ * good leads as failed.
+ */
+export declare function isStandingRefusal(reason: string): boolean;

package/node_modules/@oxygen/shared/dist/call-outcomes.js

@@ -0,0 +1,73 @@
+/**
+ * Classifying how a dial ended, for the power dialer.
+ *
+ * This exists because the BROWSER CANNOT TELL. The dial path bridges the rep's
+ * leg to Twilio immediately and then `<Dial>` rings the lead, so the softphone
+ * reports "on call" while the phone is still ringing. A 25-second call that was
+ * never answered looks exactly like a 25-second conversation from the client's
+ * side. Only the carrier knows, via `DialCallStatus` and answering-machine
+ * detection, and both arrive server-side on the status webhook.
+ *
+ * So the rule is: the power dialer advances on what the SERVER says happened,
+ * never on a client-side timer.
+ */
+const MACHINE = new Set([
+    "machine_start",
+    "machine_end_beep",
+    "machine_end_silence",
+    "machine_end_other",
+]);
+/**
+ * What should the dialer do next?
+ *
+ * Biased toward STOPPING. Auto-advancing past a live human is the worst failure
+ * this component has — it hangs up on a prospect who answered — so anything
+ * ambiguous returns `pending`, and a caller that runs out of patience must stop
+ * rather than advance.
+ */
+export function classifyDialOutcome(outcome) {
+    if (outcome.refusedReason)
+        return { kind: "refused", reason: outcome.refusedReason };
+    // AMD is the strongest signal and it can land BEFORE the call ends, so it is
+    // checked before status.
+    if (outcome.answeredBy === "human")
+        return { kind: "human" };
+    if (outcome.answeredBy && MACHINE.has(outcome.answeredBy)) {
+        return { kind: "auto_advance", disposition: "voicemail" };
+    }
+    if (outcome.answeredBy === "fax") {
+        return { kind: "auto_advance", disposition: "failed" };
+    }
+    switch (outcome.status) {
+        case "no_answer":
+            return { kind: "auto_advance", disposition: "no_answer" };
+        case "busy":
+            return { kind: "auto_advance", disposition: "busy" };
+        case "failed":
+        case "canceled":
+            return { kind: "auto_advance", disposition: "failed" };
+        case "completed":
+            // Completed with no AMD verdict means someone or something picked up and
+            // the call ran its course. Treated as a human: a real conversation that
+            // gets auto-dispositioned and skipped past is unrecoverable, while a
+            // machine that stops the queue costs one click.
+            return { kind: "human" };
+        case "refused":
+            return { kind: "refused", reason: outcome.refusedReason ?? "A guardrail refused the call." };
+        default:
+            return { kind: "pending" };
+    }
+}
+/** Guardrail refusals that will refuse EVERY subsequent dial, not just this one. */
+const STANDING_REFUSALS = new Set(["daily_cap", "number_health", "credits"]);
+/**
+ * Should a refusal stop the whole session rather than skip one lead?
+ *
+ * A suppressed contact or a bad calling window is specific to that lead — skip
+ * it. An exhausted daily cap, an unhealthy pool, or an empty credit balance
+ * refuses everyone, so continuing would march through the entire queue marking
+ * good leads as failed.
+ */
+export function isStandingRefusal(reason) {
+    return STANDING_REFUSALS.has(reason);
+}

package/node_modules/@oxygen/shared/dist/cli-result.js

@@ -50,6 +50,7 @@ export function exitCodeForErrorCode(code) {
             return 6;
         case "max_credits_required":
         case "approval_required":
+        case "effect_unknown_approval_required":
         case "spend_cap_required":
         case "spend_cap_too_low":
         case "insufficient_credits":

package/node_modules/@oxygen/shared/dist/credit-guidance.js

@@ -27,7 +27,9 @@ export function buildCreditGuidance(input) {
             recommended_max_credits: recommendedMaxCredits,
             available_credits: availableCredits,
             credit_posture: "sufficient",
-            credit_guidance: "Credits are sufficient; use recommended_max_credits as a safety ceiling. Unused credits are not spent.",
+            credit_guidance: "Credits are sufficient; use recommended_max_credits as a safety ceiling "
+                + `(the estimate plus ${Math.round((DEFAULT_HEADROOM_MULTIPLIER - 1) * 100)}% headroom, so a row that costs more than estimated still completes). `
+                + "Unused credits are not spent.",
         };
     }
     return {

package/node_modules/@oxygen/shared/dist/crm-reply-events.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The inbound-reply CRM signal contract, shared by apps/web and apps/worker.
+ *
+ * The same logical event — "a lead's reply settled on a status" — is dispatched
+ * from three places: the on-demand `inbox analyze` route, the raw provider
+ * webhooks, and the worker's background reply bridge. They must agree on the
+ * event name AND on the external event id, because that id is the dedupe key:
+ * `recordWorkflowEvent` collapses repeats on it, and the run idempotency key is
+ * derived from it. If the worker and the web route built the id differently,
+ * the same conversation would assert the same person twice.
+ */
+/** Workflow event source for every inbound GTM signal that advances a lead. */
+export declare const CRM_WORKFLOW_EVENT_SOURCE = "crm";
+/**
+ * The single channel-neutral "inbound reply → lead stage" event. A raw reply
+ * and a classified reply both dispatch this one event; per-channel raw reply
+ * events are deliberately not modelled, because an event no standing template
+ * consumes is a dead signal.
+ */
+export declare const CRM_EMAIL_REPLY_CLASSIFIED_EVENT = "email_reply_classified";
+/**
+ * Channel an inbound CRM signal arrived on. Selects which person identity the
+ * standing lead-stage router resolves on (email → email, linkedin →
+ * linkedin_url, whatsapp → external_id "whatsapp:<phone>").
+ */
+export type CrmSignalChannel = "email" | "linkedin" | "whatsapp";
+/**
+ * Deterministic external event id for one conversation settling on one status.
+ *
+ * Keyed by (channel, conversation, status) rather than by conversation alone so
+ * a RE-classification to a different status is a genuinely new event that can
+ * move the lead's stage again, while a re-analysis confirming the same status
+ * dedupes to the original event and never re-asserts.
+ */
+export declare function crmReplyExternalEventId(channel: CrmSignalChannel | string, conversationId: string, status: string): string;

package/node_modules/@oxygen/shared/dist/crm-reply-events.js

@@ -0,0 +1,31 @@
+/**
+ * The inbound-reply CRM signal contract, shared by apps/web and apps/worker.
+ *
+ * The same logical event — "a lead's reply settled on a status" — is dispatched
+ * from three places: the on-demand `inbox analyze` route, the raw provider
+ * webhooks, and the worker's background reply bridge. They must agree on the
+ * event name AND on the external event id, because that id is the dedupe key:
+ * `recordWorkflowEvent` collapses repeats on it, and the run idempotency key is
+ * derived from it. If the worker and the web route built the id differently,
+ * the same conversation would assert the same person twice.
+ */
+/** Workflow event source for every inbound GTM signal that advances a lead. */
+export const CRM_WORKFLOW_EVENT_SOURCE = "crm";
+/**
+ * The single channel-neutral "inbound reply → lead stage" event. A raw reply
+ * and a classified reply both dispatch this one event; per-channel raw reply
+ * events are deliberately not modelled, because an event no standing template
+ * consumes is a dead signal.
+ */
+export const CRM_EMAIL_REPLY_CLASSIFIED_EVENT = "email_reply_classified";
+/**
+ * Deterministic external event id for one conversation settling on one status.
+ *
+ * Keyed by (channel, conversation, status) rather than by conversation alone so
+ * a RE-classification to a different status is a genuinely new event that can
+ * move the lead's stage again, while a re-analysis confirming the same status
+ * dedupes to the original event and never re-asserts.
+ */
+export function crmReplyExternalEventId(channel, conversationId, status) {
+    return `crm:${channel}:${conversationId}:${status}`;
+}

package/node_modules/@oxygen/shared/dist/dial-guardrail-overrides.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The closed vocabulary of per-lead guardrail waivers.
+ *
+ * Six guardrails stand between a rep pressing dial and a stranger's phone
+ * ringing. Three of them are POLICY defaults that a human can reasonably know
+ * better than the default for one specific lead — a prospect who says "call me
+ * at 7am", a lead whose timezone we never captured but whose rep knows where
+ * they sit, a single follow-up worth spending one more dial from a number that
+ * has hit today's ramp. The rest are not: do-not-call carries statutory
+ * damages, credits are arithmetic, a released number cannot originate a call,
+ * and a destination the carrier will not accept does not become reachable
+ * because someone ticked a box.
+ *
+ * So this list is deliberately SHORT and deliberately CLOSED. It lives in
+ * @oxygen/shared because it is the only package both @oxygen/tenant-db (which
+ * stores the waivers) and @oxygen/integrations (which honours them) can import,
+ * and because the tenant migration's CHECK constraint has to agree with it.
+ *
+ * NOTE that this is NOT a subset of DialGuardrail, and must never be turned into
+ * one. "unknown_timezone" is the null-hour BRANCH of the calling_window
+ * guardrail, not a guardrail of its own. Keeping them separate is the whole
+ * point: "I accept that we do not know their local time" is a different, smaller
+ * statement than "call this person at any hour", and collapsing the two would
+ * silently sell the second to anyone who meant the first.
+ */
+export declare const DIAL_GUARDRAIL_OVERRIDES: readonly ["calling_window", "unknown_timezone", "daily_cap"];
+export type DialGuardrailOverride = (typeof DIAL_GUARDRAIL_OVERRIDES)[number];
+export declare function isDialGuardrailOverride(value: unknown): value is DialGuardrailOverride;
+/**
+ * What each waiver actually buys, in the words a rep or an agent reads.
+ *
+ * Phrased as the CONSEQUENCE rather than the mechanism ("may be called outside
+ * …" rather than "skips the calling_window check") because the person choosing
+ * it is deciding whether to accept that consequence, not which branch to skip.
+ */
+export declare const DIAL_GUARDRAIL_OVERRIDE_LABELS: Record<DialGuardrailOverride, string>;
+/**
+ * Normalize whatever came out of the database into the canonical shape.
+ *
+ * Fails SOFT, unlike almost everything else on the dial path, and that is
+ * deliberate: this reads a text[] column, and the failure modes are a NULL from
+ * a row written before the column existed, or a value some future migration
+ * retired. Neither should stop a rep from dialing a lead — dropping an
+ * unrecognized waiver is strictly the SAFER outcome, because the guardrail it
+ * would have waived simply runs. Writes are validated separately and loudly.
+ *
+ * Deduped and returned in DIAL_GUARDRAIL_OVERRIDES order so the audit column and
+ * every API payload read the same regardless of insertion order.
+ */
+export declare function normalizeDialGuardrailOverrides(value: unknown): DialGuardrailOverride[];

package/node_modules/@oxygen/shared/dist/dial-guardrail-overrides.js

@@ -0,0 +1,65 @@
+/**
+ * The closed vocabulary of per-lead guardrail waivers.
+ *
+ * Six guardrails stand between a rep pressing dial and a stranger's phone
+ * ringing. Three of them are POLICY defaults that a human can reasonably know
+ * better than the default for one specific lead — a prospect who says "call me
+ * at 7am", a lead whose timezone we never captured but whose rep knows where
+ * they sit, a single follow-up worth spending one more dial from a number that
+ * has hit today's ramp. The rest are not: do-not-call carries statutory
+ * damages, credits are arithmetic, a released number cannot originate a call,
+ * and a destination the carrier will not accept does not become reachable
+ * because someone ticked a box.
+ *
+ * So this list is deliberately SHORT and deliberately CLOSED. It lives in
+ * @oxygen/shared because it is the only package both @oxygen/tenant-db (which
+ * stores the waivers) and @oxygen/integrations (which honours them) can import,
+ * and because the tenant migration's CHECK constraint has to agree with it.
+ *
+ * NOTE that this is NOT a subset of DialGuardrail, and must never be turned into
+ * one. "unknown_timezone" is the null-hour BRANCH of the calling_window
+ * guardrail, not a guardrail of its own. Keeping them separate is the whole
+ * point: "I accept that we do not know their local time" is a different, smaller
+ * statement than "call this person at any hour", and collapsing the two would
+ * silently sell the second to anyone who meant the first.
+ */
+export const DIAL_GUARDRAIL_OVERRIDES = [
+    "calling_window",
+    "unknown_timezone",
+    "daily_cap",
+];
+const OVERRIDE_SET = new Set(DIAL_GUARDRAIL_OVERRIDES);
+export function isDialGuardrailOverride(value) {
+    return typeof value === "string" && OVERRIDE_SET.has(value);
+}
+/**
+ * What each waiver actually buys, in the words a rep or an agent reads.
+ *
+ * Phrased as the CONSEQUENCE rather than the mechanism ("may be called outside
+ * …" rather than "skips the calling_window check") because the person choosing
+ * it is deciding whether to accept that consequence, not which branch to skip.
+ */
+export const DIAL_GUARDRAIL_OVERRIDE_LABELS = {
+    calling_window: "May be called outside the 9:00-20:00 local calling window.",
+    unknown_timezone: "May be called even though we cannot resolve their local time.",
+    daily_cap: "May be dialed even when the chosen number has hit today's cap.",
+};
+/**
+ * Normalize whatever came out of the database into the canonical shape.
+ *
+ * Fails SOFT, unlike almost everything else on the dial path, and that is
+ * deliberate: this reads a text[] column, and the failure modes are a NULL from
+ * a row written before the column existed, or a value some future migration
+ * retired. Neither should stop a rep from dialing a lead — dropping an
+ * unrecognized waiver is strictly the SAFER outcome, because the guardrail it
+ * would have waived simply runs. Writes are validated separately and loudly.
+ *
+ * Deduped and returned in DIAL_GUARDRAIL_OVERRIDES order so the audit column and
+ * every API payload read the same regardless of insertion order.
+ */
+export function normalizeDialGuardrailOverrides(value) {
+    if (!Array.isArray(value))
+        return [];
+    const present = new Set(value.filter(isDialGuardrailOverride));
+    return DIAL_GUARDRAIL_OVERRIDES.filter((override) => present.has(override));
+}

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

@@ -1,4 +1,4 @@
-export declare const AGENCY_DIRECTORY_SERVICES: readonly ["Cold Email", "LinkedIn Outbound", "Lead Sourcing & Enrichment", "GTM Engineering", "Outreach Strategy & Consulting", "Copywriting & Messaging", "Deliverability & Infrastructure", "RevOps & CRM", "Campaign Management", "Training & Coaching"];
+export declare const AGENCY_DIRECTORY_SERVICES: readonly ["Cold Email", "LinkedIn Outbound", "Lead Sourcing & Enrichment", "GTM Engineering", "Outreach Strategy & Consulting", "Copywriting & Messaging", "Deliverability & Infrastructure", "RevOps & CRM", "Campaign Management", "Training & Coaching", "Education"];
 export type AgencyDirectoryService = (typeof AGENCY_DIRECTORY_SERVICES)[number];
 export declare const AGENCY_DIRECTORY_REGIONS: readonly ["North America", "LATAM", "UK & Ireland", "DACH", "Nordics", "Europe", "APAC", "Middle East & Africa", "Global"];
 export type AgencyDirectoryRegion = (typeof AGENCY_DIRECTORY_REGIONS)[number];

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

@@ -13,6 +13,7 @@ export const AGENCY_DIRECTORY_SERVICES = [
     "RevOps & CRM",
     "Campaign Management",
     "Training & Coaching",
+    "Education",
 ];
 export const AGENCY_DIRECTORY_REGIONS = [
     "North America",