@oxygen-agent/cli 1.936.1 → 1.948.1

package/node_modules/@oxygen/shared/dist/capability-discovery.js

@@ -210,11 +210,11 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         primitive: "tables",
         owns: "Typed working datasets, rows, formulas, AI/tool/waterfall columns, reusable Functions with isolated drafts and published versions, cell state, projects, and run provenance.",
         notFor: "Canonical CRM truth, message cadence, or an off-platform spreadsheet runtime.",
-        execution: "Create and run work in hosted OXYGEN Tables; validate a small sample before bounded paid runs.",
+        execution: "Create and run work in hosted OXYGEN Tables; validate a small sample before bounded paid runs. For standard person or company enrichment, `columns add <table> --preset person_enrich|company_enrich` (MCP oxygen_columns_add with preset) adds the maintained bundle in one call before any hand-built tool column.",
         posture: "mixed",
         gatewayTools: ["oxygen_tables_create", "oxygen_columns_add", "oxygen_enrich_column_preview", "oxygen_tables_link_bulk", "oxygen_callables_manage"],
         gatewayCommands: ["tables create", "columns add", "enrich-column preview", "tables link", "functions list", "functions draft"],
-        skills: ["oxygen-gtm", "oxygen-table-tidy", "oxygen-diagnostics", "oxygen-clay-migration"],
+        skills: ["oxygen-gtm", "oxygen-table-tidy", "oxygen-diagnostics", "oxygen-clay-migration", "oxygen-linkedin-marketing"],
         endpointSections: ["action-columns", "callables", "functions", "columns", "company-enrichment", "enrich-column", "enrichment", "projects", "table-action-items", "table-action-runs", "table-ingestion-runs", "tables"],
         // "link"/"join"/"connect"/"relate" route here for `tables link`. Added after a
         // blind user eval asked for exactly "link two tables" and was routed to
@@ -335,10 +335,13 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         execution: "Create and schedule on OXYGEN; explicit approval releases the hosted publisher.",
         posture: "external_write",
         gatewayTools: ["oxygen_publishing_posts_create", "oxygen_publishing_posts_list", "oxygen_publishing_posts_approve", "oxygen_ugc_get"],
-        gatewayCommands: ["publishing posts create", "publishing posts list", "publishing posts approve", "ugc programs list"],
+        gatewayCommands: ["publishing posts create", "publishing posts list", "publishing posts approve", "ugc programs list", "ugc programs duplicate", "ugc programs archive"],
         skills: ["oxygen-linkedin-marketing", "oxygen-ugc"],
         endpointSections: ["publishing", "ugc"],
-        intentTerms: ["publish", "publishing", "schedule post", "content calendar", "posting calendar", "approve post", "social publishing", "ugc", "creator program", "user generated content", "creator voice", "sponsored creator"],
+        // "remove program" / "delete program" landed on route: null in a blind eval
+        // (2026-09-10); a program is a UGC noun here, and its lifecycle verbs must
+        // resolve to the group that owns `ugc programs archive|delete|duplicate`.
+        intentTerms: ["publish", "publishing", "schedule post", "content calendar", "posting calendar", "approve post", "social publishing", "ugc", "creator program", "user generated content", "creator voice", "sponsored creator", "ugc program", "archive program", "delete program", "remove program", "duplicate program", "copy program"],
     },
     {
         id: "workflows",
@@ -555,6 +558,13 @@ export function serializeCapabilityRoute(route) {
 function normalizeIntent(query) {
     return query.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
 }
+function isLinkedInProfileWatcherIntent(query) {
+    return /\blinkedin\b/.test(query)
+        && /\bprofiles?\b/.test(query)
+        && /\b(watcher|watch|watching|monitor|monitoring|daily|every day|recurring)\b/.test(query)
+        && (/\b(engagers?|engaging|engagement|reactions?|comments?|posts?)\b/.test(query) || /\bprofile watcher\b/.test(query))
+        && !isNetNewLinkedInInitiation(query);
+}
 function explicitCapabilityIntent(query) {
     if (/\b(infographic|graphic designer|render html|carousel pages|visual design|gtm flow image)\b/.test(query))
         return ROUTE_BY_ID.get("visual-rendering") ?? null;
@@ -574,6 +584,8 @@ function explicitCapabilityIntent(query) {
     if (isMailboxOnboardingIntent(query)) {
         return ROUTE_BY_ID.get("sending-infrastructure") ?? null;
     }
+    if (isLinkedInProfileWatcherIntent(query))
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
     if (isHostedWorkflowIntent(query))
         return ROUTE_BY_PRIMITIVE.get("workflows") ?? null;
     if (isOwnedPostCommentIntent(query))
@@ -612,6 +624,17 @@ function explicitCapabilityIntent(query) {
     if (/\b(my|our|own)\b.{0,40}\blinkedin\b.{0,40}\b(post )?engagers?\b/.test(query)) {
         return ROUTE_BY_PRIMITIVE.get("signals") ?? null;
     }
+    // Grading addresses a row ALREADY holds — "verify these emails", "which are
+    // safe to send", "catch-all or valid" — is Tables work (the Email verification
+    // column: `columns add --capability verify_email`, previewed and run through
+    // `enrich-column`), with `verify email` as the one-shot twin. Without this
+    // rule the bare word "email" scored the Messages card, and a 2026-09-10 blind
+    // user asking "verify email deliverability safe to send" was routed to
+    // `email send`. Sits after the mailbox rules above so warm-up and sender
+    // deliverability keep their owner, and after the scheduling rule so "every
+    // Monday verify new signups" still lands on Workflows.
+    if (isEmailVerificationIntent(query))
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
     if (/\b(recipe|playbook|proven play|what should i do)\b/.test(query)) {
         return ROUTE_BY_PRIMITIVE.get("recipes") ?? null;
     }
@@ -752,12 +775,27 @@ function recommendationsFor(card, query) {
         };
     }
     if (card.primitive === "tables") {
+        if (isLinkedInProfileWatcherIntent(query)) {
+            return {
+                tools: ["oxygen_tables_watcher"],
+                commands: ["tables watcher preview", "tables watcher create", "tables watcher get", "tables watcher update", "tables watcher pause", "tables watcher resume"],
+            };
+        }
         if (/\b(table )?(action )?runs?\b/.test(query)) {
             return {
                 tools: ["oxygen_table_runs_get", "oxygen_table_runs_items", "oxygen_table_runs_wait", "oxygen_table_runs_retry_failed"],
                 commands: ["table-runs get", "table-runs items", "table-runs wait", "table-runs retry-failed"],
             };
         }
+        if (isEmailVerificationIntent(query)) {
+            // Define-without-running first (0 credits), then the free preview that
+            // prices it, then the approved run, then the one-shot for a handful of
+            // addresses that never needed a table.
+            return {
+                tools: ["oxygen_columns_add", "oxygen_enrich_column_preview", "oxygen_enrich_column_run", "oxygen_verify_email"],
+                commands: ["columns add", "enrich-column preview", "enrich-column run", "verify email"],
+            };
+        }
         if (/\b(waterfall|enrich|enrichment|work email|mobile phone)\b/.test(query)) {
             return {
                 tools: ["oxygen_enrich_column_preview", "oxygen_columns_add", "oxygen_enrich_column_run", "oxygen_table_runs_get"],
@@ -889,7 +927,7 @@ function recommendationsFor(card, query) {
     if (card.primitive === "signals" && /\blinkedin\b.{0,40}\bengagers?\b/.test(query)) {
         return {
             tools: ["oxygen_engagement_list_engagers", "oxygen_signals_list", "oxygen_signals_leads_today"],
-            commands: ["engagement list", "signals list", "signals leads-today"],
+            commands: ["engagement engagers", "signals list", "signals leads-today"],
         };
     }
     if (card.id === "connected-whatsapp" && /\b(account|connect|limits?|sync)\b/.test(query)) {
@@ -900,6 +938,16 @@ function recommendationsFor(card, query) {
     }
     return { tools: [...card.gatewayTools], commands: [...card.gatewayCommands] };
 }
+// An email-VERIFICATION ask names a grading verb next to the addresses, or the
+// addresses next to a grade. "check my emails" is deliberately not matched
+// (that is an inbox), and bare "deliverability" is left to the sending rail —
+// only "are these emails deliverable" counts. Bare "bounce" describes an
+// observed delivery failure too; require predictive wording or "bounce risk".
+function isEmailVerificationIntent(query) {
+    const gradeThenAddress = /\b(verif(?:y|ied|ication)|validat(?:e|ed|ion)|grade|scrub|clean)\b.{0,40}\b(e ?mails?|email addresses|addresses)\b/;
+    const addressThenGrade = /\b(e ?mails?|addresses)\b.{0,40}\b(verif(?:y|ied|ication)|validat(?:e|ed|ion)|valid|invalid|deliverable|(?:will|would|might) bounce|bounce risk|risky|safe to (?:send|email)|catch ?all|accept ?all)\b/;
+    return gradeThenAddress.test(query) || addressThenGrade.test(query);
+}
 function isInboxAvatarIntent(query) {
     return /\b(avatar|profile (?:picture|photo)|headshot|hosted (?:picture|image)|mailbox (?:picture|photo))\b/.test(query);
 }

package/node_modules/@oxygen/shared/dist/email-dsn.d.ts

@@ -0,0 +1,60 @@
+/**
+ * PURE classifier for delivery-status notifications (bounce NDRs / DSNs) that
+ * land back in a sending mailbox's own inbox.
+ *
+ * WHY this exists: a mailbox-provider reputation block is the loudest
+ * deliverability signal a workspace ever receives, and it arrives as an ordinary
+ * inbound email — "Message rejected", "support.google.com/mail/answer/69585" —
+ * that no OXYGEN surface reads. A warm-up vendor reporting 96% inbox placement
+ * cannot contradict it, because the vendor only measures its own seed network.
+ * Classifying the DSN turns the workspace's own inbox into first-party
+ * deliverability evidence: OXYGEN's send log said we sent, the DSN says the
+ * receiving provider refused it, and only the second one is the truth.
+ *
+ * Pure by design — no clock, no I/O, no provider call — so the same
+ * classification runs in the tenant rollup, a worker sweep, and a unit test.
+ * Output is stable machine data (kinds and codes), never prose.
+ */
+/** What the notification actually says happened. */
+export type DeliveryStatusNotificationKind = 
+/** The receiving provider refused the message on reputation/policy grounds. */
+"provider_rejected"
+/** The address does not exist (list hygiene, not reputation). */
+ | "no_such_user"
+/** The recipient mailbox is over quota. */
+ | "mailbox_full"
+/** Transient: retried, not dead. */
+ | "delayed"
+/**
+ * The envelope proves it is a DSN, but nothing classifiable was stored — the
+ * body was never synced, so only the subject survives. Kept distinct from
+ * "other" because counting these as "other" reads as "we looked and found
+ * nothing wrong", when the truth is that we could not look.
+ */
+ | "unclassified"
+/** A DSN with real content we can recognize but not attribute. */
+ | "other";
+/** Every kind, in one place, so callers can build a complete counts map. */
+export declare const DELIVERY_STATUS_NOTIFICATION_KINDS: readonly ["provider_rejected", "no_such_user", "mailbox_full", "delayed", "unclassified", "other"];
+/** Which mailbox provider generated the notification, when it is knowable. */
+export type DeliveryStatusNotificationProvider = "google" | "microsoft" | "unknown";
+export type DeliveryStatusNotification = {
+    kind: DeliveryStatusNotificationKind;
+    provider: DeliveryStatusNotificationProvider;
+    /** The address the original message was addressed to, when the DSN names it. */
+    recipient: string | null;
+    /** Enhanced status code (5.7.1) when present, else the bare SMTP reply (550). */
+    smtpCode: string | null;
+};
+/**
+ * Classify one stored inbound message as a delivery-status notification.
+ *
+ * Returns null when the message is not a DSN at all — the caller's SQL prefilter
+ * is intentionally wide, and a false positive here would invent a deliverability
+ * incident out of a customer reply.
+ */
+export declare function classifyDeliveryStatusNotification(input: {
+    fromAddress?: string | null;
+    subject?: string | null;
+    bodyText?: string | null;
+}): DeliveryStatusNotification | null;

package/node_modules/@oxygen/shared/dist/email-dsn.js

@@ -0,0 +1,120 @@
+/**
+ * PURE classifier for delivery-status notifications (bounce NDRs / DSNs) that
+ * land back in a sending mailbox's own inbox.
+ *
+ * WHY this exists: a mailbox-provider reputation block is the loudest
+ * deliverability signal a workspace ever receives, and it arrives as an ordinary
+ * inbound email — "Message rejected", "support.google.com/mail/answer/69585" —
+ * that no OXYGEN surface reads. A warm-up vendor reporting 96% inbox placement
+ * cannot contradict it, because the vendor only measures its own seed network.
+ * Classifying the DSN turns the workspace's own inbox into first-party
+ * deliverability evidence: OXYGEN's send log said we sent, the DSN says the
+ * receiving provider refused it, and only the second one is the truth.
+ *
+ * Pure by design — no clock, no I/O, no provider call — so the same
+ * classification runs in the tenant rollup, a worker sweep, and a unit test.
+ * Output is stable machine data (kinds and codes), never prose.
+ */
+/** Every kind, in one place, so callers can build a complete counts map. */
+export const DELIVERY_STATUS_NOTIFICATION_KINDS = [
+    "provider_rejected",
+    "no_such_user",
+    "mailbox_full",
+    "delayed",
+    "unclassified",
+    "other",
+];
+// A message only enters classification when its envelope looks like a DSN. The
+// SQL prefilter that feeds this is deliberately loose (ILIKE), so this gate is
+// what keeps an ordinary customer reply that happens to contain the word
+// "blocked" out of the deliverability evidence.
+const DSN_FROM_PATTERN = /(mailer-daemon|mail-daemon|postmaster|microsoftexchange)/i;
+const DSN_SUBJECT_PATTERN = /(undeliver|delivery status notification|mail delivery fail|delivery has failed|returned mail)/i;
+const GOOGLE_BLOCK_URL = /support\.google\.com\/mail\/answer\/69585/i;
+const GOOGLE_FROM = /@(?:[a-z0-9-]+\.)*(?:googlemail|google)\.com\b/i;
+const MICROSOFT_FROM = /(?:@(?:[a-z0-9-]+\.)*(?:outlook|office365|hotmail|microsoft)\.com\b|microsoftexchange|\bexchange\b)/i;
+const MICROSOFT_BODY = /(microsoft exchange|exchange server|office\s?365)/i;
+// Enhanced status code (RFC 3463): class.subject.detail, where subject/detail can
+// be multi-digit (Google emits 5.7.708). Kept separate from the bare 3-digit SMTP
+// reply so a caller can tell "550" from "5.7.1".
+const ENHANCED_CODE = /\b([2-5]\.\d{1,3}\.\d{1,3})\b/;
+const SMTP_REPLY_CODE = /\b([2-5]\d{2})\b/;
+const REPUTATION_BLOCK = /\b5\.7\.\d{1,3}\b/;
+const MAILBOX_FULL_CODE = /\b[45]\.2\.2\b/;
+const NO_SUCH_USER_CODE = /\b5\.1\.\d{1,3}\b/;
+const TRANSIENT_CODE = /(\b4\.\d{1,3}\.\d{1,3}\b|\b4\d{2}\b)/;
+const MAILBOX_FULL_TEXT = /(mailbox (?:is )?full|over quota|quota exceeded|insufficient storage)/i;
+const NO_SUCH_USER_TEXT = /(does ?n[o']?t exist|nosuchuser|no such user|user unknown|unknown user|address not found|recipient (?:address )?(?:not found|rejected)|invalid recipient)/i;
+const PROVIDER_REJECTED_TEXT = /(message rejected|has been blocked|\bblocked\b|\bbanned\b|\bspam\b|local policy violation|unsolicited|reputation)/i;
+const TRANSIENT_TEXT = /(temporar|will retry|try again later|rate ?limit|throttl)/i;
+// Greedy address capture: the character class already stops at whitespace and
+// angle brackets, so trailing sentence punctuation is stripped afterwards. A lazy
+// capture would stop at the dot inside "gmail.com".
+const ADDRESS = "([^\\s<>,;()]+@[^\\s<>,;()]+)";
+const RECIPIENT_PATTERNS = [
+    new RegExp(`your message to\\s+<?${ADDRESS}>?`, "i"),
+    new RegExp(`\\bto\\s+<?${ADDRESS}>?\\s+(?:was|were|could not|couldn't|has been|had been)`, "i"),
+    // Machine-readable half of a real RFC 3464 report, when the provider sends one.
+    new RegExp(`(?:final|original)-recipient:\\s*rfc822;\\s*<?${ADDRESS}>?`, "i"),
+];
+function readRecipient(haystack) {
+    for (const pattern of RECIPIENT_PATTERNS) {
+        const match = pattern.exec(haystack);
+        const value = match?.[1]?.replace(/[.,;:>]+$/, "").trim().toLowerCase();
+        if (value && value.includes("@"))
+            return value;
+    }
+    return null;
+}
+function readProvider(from, haystack) {
+    // The 69585 URL is decisive: only Google emits it, and it is the exact article
+    // a Gmail reputation block cites.
+    if (GOOGLE_BLOCK_URL.test(haystack) || GOOGLE_FROM.test(from))
+        return "google";
+    if (MICROSOFT_FROM.test(from) || MICROSOFT_BODY.test(haystack))
+        return "microsoft";
+    return "unknown";
+}
+function readKind(subject, haystack, hasBody) {
+    // Order is load-bearing. A Google "(Delay)" report can quote block-sounding
+    // prose while the message is still queued, so the transient marker wins first;
+    // an explicit enhanced code then beats keyword matching, because "blocked" and
+    // "spam" appear in boilerplate that a 5.1.1 no-such-user report also carries.
+    if (/\(delay\)/i.test(subject))
+        return "delayed";
+    if (REPUTATION_BLOCK.test(haystack))
+        return "provider_rejected";
+    if (MAILBOX_FULL_CODE.test(haystack) || MAILBOX_FULL_TEXT.test(haystack))
+        return "mailbox_full";
+    if (NO_SUCH_USER_CODE.test(haystack) || NO_SUCH_USER_TEXT.test(haystack))
+        return "no_such_user";
+    if (PROVIDER_REJECTED_TEXT.test(haystack))
+        return "provider_rejected";
+    if (TRANSIENT_CODE.test(haystack) || TRANSIENT_TEXT.test(haystack))
+        return "delayed";
+    // Nothing matched AND there was no body to match against: the sync stored the
+    // envelope only. Reporting that as "other" would be a false clean.
+    return hasBody ? "other" : "unclassified";
+}
+/**
+ * Classify one stored inbound message as a delivery-status notification.
+ *
+ * Returns null when the message is not a DSN at all — the caller's SQL prefilter
+ * is intentionally wide, and a false positive here would invent a deliverability
+ * incident out of a customer reply.
+ */
+export function classifyDeliveryStatusNotification(input) {
+    const from = typeof input.fromAddress === "string" ? input.fromAddress : "";
+    const subject = typeof input.subject === "string" ? input.subject : "";
+    const body = typeof input.bodyText === "string" ? input.bodyText : "";
+    if (!DSN_FROM_PATTERN.test(from) && !DSN_SUBJECT_PATTERN.test(subject))
+        return null;
+    const haystack = `${subject}\n${body}`;
+    const smtpCode = ENHANCED_CODE.exec(haystack)?.[1] ?? SMTP_REPLY_CODE.exec(haystack)?.[1] ?? null;
+    return {
+        kind: readKind(subject, haystack, body.trim().length > 0),
+        provider: readProvider(from, haystack),
+        recipient: readRecipient(haystack),
+        smtpCode,
+    };
+}

package/node_modules/@oxygen/shared/dist/email-warmup-readiness.d.ts

@@ -0,0 +1,64 @@
+/**
+ * PURE warm-up readiness rule: what daily cold volume a sending mailbox can
+ * actually carry, given its warm-up age rather than a provider's opinion of it.
+ *
+ * WHY it lives in @oxygen/shared and not next to the other email-health rules in
+ * @oxygen/integrations: the tenant rollup computes this per mailbox, and
+ * @oxygen/tenant-db must never import @oxygen/integrations (integrations depends
+ * on tenant-db). Duplicating the thresholds so each package could own a copy is
+ * exactly how two surfaces start recommending different numbers, so the rule is
+ * defined once here and re-exported from
+ * packages/integrations/src/email-health/health-state.ts, which stays the
+ * email-health surface every caller reads.
+ *
+ * DIRECTIONAL, like everything else in the deliverability cluster: it produces a
+ * recommendation and a launch-preview warning. It never clamps a cap, never
+ * pauses a mailbox, and never changes what a sequence sends.
+ */
+/** Below this warm-up day a mailbox should carry only the starter cold volume. */
+export declare const WARMUP_EARLY_DAY_LIMIT = 14;
+/** Below this warm-up day a mailbox should stay at the reduced cold volume. */
+export declare const WARMUP_ESTABLISHED_DAY_LIMIT = 28;
+/** Recommended cold sends/day before day 14 (and for an un-warmed young mailbox). */
+export declare const WARMUP_EARLY_DAILY_CAP = 5;
+/** Recommended cold sends/day between day 14 and day 28. */
+export declare const WARMUP_ESTABLISHED_DAILY_CAP = 10;
+/** A warm-up health score under this is treated as "not ready for volume". */
+export declare const WARMUP_HEALTH_SCORE_FLOOR = 60;
+/** Hard-bounce rate above which a fleet is burning its domains, not just its list. */
+export declare const HARD_BOUNCE_RATE_CEILING = 0.03;
+/** Below this send volume a bounce rate is noise, not a signal. */
+export declare const HARD_BOUNCE_RATE_MIN_SENDS = 20;
+/**
+ * The DIRECTIONAL per-mailbox daily cold-send ceiling warm-up readiness supports,
+ * or null when nothing in the evidence argues for holding volume back.
+ *
+ * Pure — the caller resolves `mailboxAgeDays` from created_at, so this stays
+ * clock-free and identical on every surface.
+ *
+ *   - warm-up day < 14                                    -> 5/day
+ *   - mailbox younger than 28 days, with either no active
+ *     warm-up or no warm-up day reported at all           -> 5/day
+ *   - warm-up day < 28                                    -> 10/day
+ *   - warm-up health score < 60                           -> at most 5/day
+ *   - otherwise                                           -> null (no advice)
+ *
+ * The second rule is the one that matters for a freshly provisioned fleet: a
+ * mailbox whose warm-up never started (state "unknown") reports no day at all,
+ * and a rule keyed only on the day number would have said nothing about the exact
+ * mailboxes most likely to get blocked.
+ */
+export declare function recommendedDailyCapForWarmup(input: {
+    warmupState?: string | null;
+    warmupDay?: number | null;
+    warmupHealthScore?: number | null;
+    mailboxAgeDays?: number | null;
+}): number | null;
+/**
+ * True when a hard-bounce count is high enough, over enough sends, to be a real
+ * reputation problem rather than list noise.
+ */
+export declare function hardBounceRateIsHigh(input: {
+    hardBounces: number;
+    coldSends: number;
+}): boolean;

package/node_modules/@oxygen/shared/dist/email-warmup-readiness.js

@@ -0,0 +1,90 @@
+/**
+ * PURE warm-up readiness rule: what daily cold volume a sending mailbox can
+ * actually carry, given its warm-up age rather than a provider's opinion of it.
+ *
+ * WHY it lives in @oxygen/shared and not next to the other email-health rules in
+ * @oxygen/integrations: the tenant rollup computes this per mailbox, and
+ * @oxygen/tenant-db must never import @oxygen/integrations (integrations depends
+ * on tenant-db). Duplicating the thresholds so each package could own a copy is
+ * exactly how two surfaces start recommending different numbers, so the rule is
+ * defined once here and re-exported from
+ * packages/integrations/src/email-health/health-state.ts, which stays the
+ * email-health surface every caller reads.
+ *
+ * DIRECTIONAL, like everything else in the deliverability cluster: it produces a
+ * recommendation and a launch-preview warning. It never clamps a cap, never
+ * pauses a mailbox, and never changes what a sequence sends.
+ */
+/** Below this warm-up day a mailbox should carry only the starter cold volume. */
+export const WARMUP_EARLY_DAY_LIMIT = 14;
+/** Below this warm-up day a mailbox should stay at the reduced cold volume. */
+export const WARMUP_ESTABLISHED_DAY_LIMIT = 28;
+/** Recommended cold sends/day before day 14 (and for an un-warmed young mailbox). */
+export const WARMUP_EARLY_DAILY_CAP = 5;
+/** Recommended cold sends/day between day 14 and day 28. */
+export const WARMUP_ESTABLISHED_DAILY_CAP = 10;
+/** A warm-up health score under this is treated as "not ready for volume". */
+export const WARMUP_HEALTH_SCORE_FLOOR = 60;
+/** Hard-bounce rate above which a fleet is burning its domains, not just its list. */
+export const HARD_BOUNCE_RATE_CEILING = 0.03;
+/** Below this send volume a bounce rate is noise, not a signal. */
+export const HARD_BOUNCE_RATE_MIN_SENDS = 20;
+/** Warm-up states in which a vendor is actively conditioning the mailbox. */
+const ACTIVE_WARMUP_STATES = new Set(["warming", "active"]);
+function finiteOrNull(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+ * The DIRECTIONAL per-mailbox daily cold-send ceiling warm-up readiness supports,
+ * or null when nothing in the evidence argues for holding volume back.
+ *
+ * Pure — the caller resolves `mailboxAgeDays` from created_at, so this stays
+ * clock-free and identical on every surface.
+ *
+ *   - warm-up day < 14                                    -> 5/day
+ *   - mailbox younger than 28 days, with either no active
+ *     warm-up or no warm-up day reported at all           -> 5/day
+ *   - warm-up day < 28                                    -> 10/day
+ *   - warm-up health score < 60                           -> at most 5/day
+ *   - otherwise                                           -> null (no advice)
+ *
+ * The second rule is the one that matters for a freshly provisioned fleet: a
+ * mailbox whose warm-up never started (state "unknown") reports no day at all,
+ * and a rule keyed only on the day number would have said nothing about the exact
+ * mailboxes most likely to get blocked.
+ */
+export function recommendedDailyCapForWarmup(input) {
+    const day = finiteOrNull(input.warmupDay);
+    const ageDays = finiteOrNull(input.mailboxAgeDays);
+    const healthScore = finiteOrNull(input.warmupHealthScore);
+    const warmingNow = ACTIVE_WARMUP_STATES.has((input.warmupState ?? "").trim().toLowerCase());
+    let cap = null;
+    if (day !== null && day < WARMUP_EARLY_DAY_LIMIT) {
+        cap = WARMUP_EARLY_DAILY_CAP;
+    }
+    else if (ageDays !== null &&
+        ageDays < WARMUP_ESTABLISHED_DAY_LIMIT &&
+        (day === null || !warmingNow)) {
+        // A rail that reports "warming" but no day number proves nothing about how
+        // far the ramp got, so age still governs. Gating this on !warmingNow alone
+        // left exactly that mailbox — enrolled, young, no telemetry — with no advice.
+        cap = WARMUP_EARLY_DAILY_CAP;
+    }
+    else if (day !== null && day < WARMUP_ESTABLISHED_DAY_LIMIT) {
+        cap = WARMUP_ESTABLISHED_DAILY_CAP;
+    }
+    if (healthScore !== null && healthScore < WARMUP_HEALTH_SCORE_FLOOR) {
+        cap = cap === null ? WARMUP_EARLY_DAILY_CAP : Math.min(cap, WARMUP_EARLY_DAILY_CAP);
+    }
+    return cap;
+}
+/**
+ * True when a hard-bounce count is high enough, over enough sends, to be a real
+ * reputation problem rather than list noise.
+ */
+export function hardBounceRateIsHigh(input) {
+    if (!Number.isFinite(input.coldSends) || input.coldSends < HARD_BOUNCE_RATE_MIN_SENDS) {
+        return false;
+    }
+    return input.hardBounces / input.coldSends > HARD_BOUNCE_RATE_CEILING;
+}

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

@@ -30,12 +30,17 @@ export * from "./copilot-journeys.js";
 export * from "./copilot-plan.js";
 export * from "./credit-guidance.js";
 export * from "./directory.js";
+export * from "./email-dsn.js";
+export * from "./email-warmup-readiness.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./error-redaction.js";
 export * from "./future-signup-events.js";
 export * from "./future-signup-lifecycle-projection.js";
 export * from "./feature-gates.js";
+export * from "./product-analytics-core.js";
+export * from "./product-analytics-environment.js";
+export * from "./product-analytics-events.js";
 export * from "./hosted-ai.js";
 export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
@@ -44,6 +49,7 @@ export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";
 export * from "./langfuse.js";
+export * from "./llm-usage.js";
 export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-quota-denial.js";

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

@@ -30,12 +30,17 @@ export * from "./copilot-journeys.js";
 export * from "./copilot-plan.js";
 export * from "./credit-guidance.js";
 export * from "./directory.js";
+export * from "./email-dsn.js";
+export * from "./email-warmup-readiness.js";
 export * from "./email-tracking-token.js";
 export * from "./email-unsubscribe-token.js";
 export * from "./error-redaction.js";
 export * from "./future-signup-events.js";
 export * from "./future-signup-lifecycle-projection.js";
 export * from "./feature-gates.js";
+export * from "./product-analytics-core.js";
+export * from "./product-analytics-environment.js";
+export * from "./product-analytics-events.js";
 export * from "./hosted-ai.js";
 export * from "./identifiers.js";
 export * from "./knowledge-constants.js";
@@ -44,6 +49,7 @@ export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
 export * from "./knowledge-seed-content.js";
 export * from "./langfuse.js";
+export * from "./llm-usage.js";
 export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
 export * from "./linkedin-quota-denial.js";

package/node_modules/@oxygen/shared/dist/knowledge-bootstrap.d.ts

@@ -2,28 +2,35 @@
  * Knowledge bootstrap — the once-per-workspace, automatic company research pass.
  *
  * WHAT IT IS. Exactly once in a workspace's life, OXYGEN researches the customer's
- * OWN company from the domain we already resolved at org creation
- * (control-DB `organizations.iconDomain`, `iconStatus = 'ok'`), then fills the typed
- * company profile (`ox_context.company_profile`) and writes one cited wiki page.
- * A founder who signs up should not face an empty Knowledge Graph and have to type
- * their own positioning back at us; every grounded AI action downstream (message
- * drafts, AI columns, agent runs) reads that profile, so an empty one degrades the
- * whole product's first hour.
+ * OWN company from the domain the creator typed when the workspace was created
+ * (control-DB `organizations.iconDomain`), then fills the typed company profile
+ * (`ox_context.company_profile`) and writes one cited wiki page. A founder who
+ * signs up should not face an empty Knowledge Graph and have to type their own
+ * positioning back at us; every grounded AI action downstream (message drafts, AI
+ * columns, agent runs) reads that profile, so an empty one degrades the whole
+ * product's first hour.
  *
  * WHY THIS IS NOT A VIOLATION OF THE PAID-ACTIONS RULE. `CLAUDE.md` says never run
  * paid provider actions unless the user explicitly asks. This slice is a deliberate,
- * founder-approved exception: signup IS the standing authorization, the same way an
- * armed table-webhook auto-run configuration is scoped standing permission for the
- * columns it queues. The exception is defensible ONLY because every one of the
- * following properties holds. They are load-bearing — do not drop one for
+ * founder-approved exception: naming the company at workspace creation IS the
+ * standing authorization, the same way an armed table-webhook auto-run
+ * configuration is scoped standing permission for the columns it queues — and
+ * since 2026-09-11 the pass is OXYGEN-funded, so it never draws down the
+ * customer's balance at all. The exception is defensible ONLY because every one of
+ * the following properties holds. They are load-bearing — do not drop one for
  * convenience, and if you remove one, the exception no longer stands:
  *
  *   1. CAPPED      — `KNOWLEDGE_BOOTSTRAP_MAX_CREDITS` is a hard ceiling on the whole
  *                    pass, with `KNOWLEDGE_BOOTSTRAP_ENRICHMENT_MAX_CREDITS` a tighter
- *                    sub-ceiling on the provider (external-money) half.
- *   2. CONSENTED   — it runs only for a workspace whose own domain we already derived
- *                    at signup; a personal-email signup is `skipped_personal_email`
- *                    upstream and never reaches here, so we never research a stranger.
+ *                    sub-ceiling on the provider (external-money) half. The cap bounds
+ *                    OXYGEN's own money now, and it is the same number.
+ *   2. AUTHORIZED  — it runs only for a workspace whose creator typed the company
+ *                    website into the REQUIRED field at workspace creation; that
+ *                    entry is recorded as `knowledge_bootstrap_consent` (source
+ *                    `workspace_creation`) and read FAIL-CLOSED, so a workspace that
+ *                    predates the field is never researched and a personal-email
+ *                    signup with no website never reaches the worker. We never
+ *                    research a stranger.
  *   3. JOURNALLED  — the marker below records status, timing, run id, credits and the
  *                    domain in `knowledge_state.watermarks`; the URLs read land as
  *                    immutable `page_sources` rows plus an `ingest` knowledge_log
@@ -36,6 +43,14 @@
  *                    ordinary revisioned wiki writes a human can revert.
  *   6. EXACTLY-ONCE — the marker is claimed with a conditional UPDATE, so N worker
  *                    replicas polling one tenant produce one run, never N runs.
+ *   7. OXYGEN-FUNDED — the automatic pass meters managed credits through the ordinary
+ *                    tool and AI-column lanes (so the cap, the marker and the run row
+ *                    all stay honest), and the worker then grants exactly the credits
+ *                    it used back to the workspace as an idempotent `bonus` ledger
+ *                    row keyed by the run (`KNOWLEDGE_BOOTSTRAP_COVERAGE_IDEMPOTENCY_PREFIX`).
+ *                    The customer's balance nets to zero and both rows are visible in
+ *                    their ledger. Only the AUTOMATIC pass is covered: a requested
+ *                    `--live --max-credits` re-run is the customer's own paid action.
  *
  * CAP ARITHMETIC (prices re-read from packages/integrations/src/cogs-rates.ts —
  * confirm them there rather than trusting this comment after a re-pricing):
@@ -52,8 +67,9 @@
  *                                overall ceiling.
  *   Hard cap           300 cr  — 85 cr nominal plus room for two retried synthesis
  *                                passes. 3% of the 10,000-credit signup grant
- *                                (FREE_SIGNUP_GRANT_CREDITS, ./billing.ts), so the
- *                                pass can never eat a founder's trial.
+ *                                (FREE_SIGNUP_GRANT_CREDITS, ./billing.ts), which is
+ *                                the headroom the balance gate needs even though the
+ *                                spend is granted back.
  *
  *   The obvious implementation — firecrawl.map + 3x firecrawl.scrape — costs
  *   4 x 40 = 160 cr for the SAME job, because Firecrawl bills per page. exa.contents
@@ -164,9 +180,11 @@ export type KnowledgeBootstrapMarker = {
     linkedin_url?: string | null;
 };
 /**
- * Control-DB `organizations.metadata` key carrying the workspace's recorded consent
- * to the automatic research pass. Written once at signup by the setup surface; read
- * by the worker cycle before anything is spent.
+ * Control-DB `organizations.metadata` key carrying the workspace's recorded
+ * authorization for the automatic research pass. Written once, when the creator
+ * names the company website at workspace creation (`source: "workspace_creation"`;
+ * rows written by the retired `/setup` checkbox carry `source: "signup"` and stay
+ * valid); read by the worker cycle before anything is spent.
  *
  * It lives in shared, not in either caller, so the writer and the reader cannot
  * drift onto two different key names — a silent drift there would either deny every
@@ -178,7 +196,10 @@ export declare const KNOWLEDGE_BOOTSTRAP_CONSENT_METADATA_KEY = "knowledge_boots
 export type KnowledgeBootstrapConsent = {
     /** ISO timestamp consent was recorded. Must parse; a marker that does not is not consent. */
     granted_at: string;
-    /** Where it came from, e.g. `signup`. Informational. */
+    /**
+     * Where it came from: `workspace_creation` (the required website field on the
+     * create-workspace screen) or the retired `signup` checkbox. Informational.
+     */
     source: string | null;
     /** Clerk user who accepted, when the surface knows. Informational. */
     granted_by_clerk_user_id: string | null;
@@ -227,6 +248,14 @@ export declare const KNOWLEDGE_BOOTSTRAP_LINKEDIN_METADATA_KEY = "company_linked
  * dead and the workspace is recoverable through the product.
  */
 export declare const KNOWLEDGE_BOOTSTRAP_STUCK_AFTER_MS: number;
+/**
+ * Idempotency-key prefix for the ledger row that hands an automatic pass's
+ * credits back to the workspace (property 7 above). The key is
+ * `${prefix}:${run_id}`, so one pass is covered exactly once no matter how many
+ * times the worker revisits the outcome, and a `--force` re-run — a different
+ * run — is covered only if it was itself automatic.
+ */
+export declare const KNOWLEDGE_BOOTSTRAP_COVERAGE_IDEMPOTENCY_PREFIX = "knowledge_bootstrap_coverage";
 /**
  * The one wiki page a bootstrap authors. A stable slug is what makes a re-armed pass
  * REVISE the note rather than litter the wiki with `company-research-2`.