@oxygen-agent/cli 1.936.1 → 1.982.3

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/inbox-avatar-url.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where a hosted inbox-avatar URL may be minted, and how.
+ *
+ * An avatar URL is handed to an external inbox vendor that fetches it server-side,
+ * later, possibly more than once — and Oxygen stores nothing about that hand-off
+ * afterwards, so a bad URL cannot be found again or reissued. A URL minted on a
+ * preview deployment would be baked into a vendor's mailbox record and die when
+ * that deployment does; one minted on localhost never resolves at all. So the
+ * origin is an allowlist, not "whatever host served this request", and the SAME
+ * allowlist binds every minter: the web request path (which prefers the inbound
+ * host) and the worker's LinkedIn-photo backfill (which only has the configured
+ * app URL). Two allowlists would drift, and the drift would ship as a mailbox
+ * photo that resolves from one deployment and 404s from the other.
+ */
+export declare const INBOX_AVATAR_ORIGIN_HOSTS: ReadonlySet<string>;
+/**
+ * The first candidate that is an https URL on an allowed host, normalized to
+ * `protocol//host`, or null when none qualifies. Returning null rather than a
+ * best-effort URL is the point: on localhost the only honest answer is "not from
+ * here", and an `http://localhost` URL would sail through this function only to
+ * be rejected by an https-only check one step later and much harder to read.
+ */
+export declare function resolveInboxAvatarOrigin(candidates: readonly (string | null | undefined)[]): string | null;
+/**
+ * The public, permanent URL for a stored inbox avatar on an already-resolved
+ * origin — or null when there is no origin, or the key is not an inbox avatar.
+ */
+export declare function inboxAvatarPublicUrlForOrigin(origin: string | null, storageKey: string): string | null;

package/node_modules/@oxygen/shared/dist/inbox-avatar-url.js

@@ -0,0 +1,57 @@
+/**
+ * Where a hosted inbox-avatar URL may be minted, and how.
+ *
+ * An avatar URL is handed to an external inbox vendor that fetches it server-side,
+ * later, possibly more than once — and Oxygen stores nothing about that hand-off
+ * afterwards, so a bad URL cannot be found again or reissued. A URL minted on a
+ * preview deployment would be baked into a vendor's mailbox record and die when
+ * that deployment does; one minted on localhost never resolves at all. So the
+ * origin is an allowlist, not "whatever host served this request", and the SAME
+ * allowlist binds every minter: the web request path (which prefers the inbound
+ * host) and the worker's LinkedIn-photo backfill (which only has the configured
+ * app URL). Two allowlists would drift, and the drift would ship as a mailbox
+ * photo that resolves from one deployment and 404s from the other.
+ */
+export const INBOX_AVATAR_ORIGIN_HOSTS = new Set([
+    "oxygen-agent.com",
+    "www.oxygen-agent.com",
+    "dev.oxygen-agent.com",
+]);
+const INBOX_AVATAR_KEY_PREFIX = "inbox-avatars/";
+/**
+ * The first candidate that is an https URL on an allowed host, normalized to
+ * `protocol//host`, or null when none qualifies. Returning null rather than a
+ * best-effort URL is the point: on localhost the only honest answer is "not from
+ * here", and an `http://localhost` URL would sail through this function only to
+ * be rejected by an https-only check one step later and much harder to read.
+ */
+export function resolveInboxAvatarOrigin(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            const url = new URL(candidate);
+            if (url.protocol === "https:" && INBOX_AVATAR_ORIGIN_HOSTS.has(url.host)) {
+                return `${url.protocol}//${url.host}`;
+            }
+        }
+        catch {
+            // Not a URL at all — try the next candidate.
+        }
+    }
+    return null;
+}
+/**
+ * The public, permanent URL for a stored inbox avatar on an already-resolved
+ * origin — or null when there is no origin, or the key is not an inbox avatar.
+ */
+export function inboxAvatarPublicUrlForOrigin(origin, storageKey) {
+    if (!origin || !storageKey.startsWith(INBOX_AVATAR_KEY_PREFIX))
+        return null;
+    const path = storageKey
+        .slice(INBOX_AVATAR_KEY_PREFIX.length)
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+    return `${origin}/api/inbox-avatars/${path}`;
+}

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

@@ -30,20 +30,27 @@ 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";
 export * from "./knowledge-bootstrap.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
+export * from "./knowledge-vault-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";
@@ -113,3 +120,6 @@ export declare function isVersionGreater(a: string, b: string): boolean;
 /** True when `a` is a strictly lesser semantic version than `b`. */
 export declare function isVersionLess(a: string, b: string): boolean;
 export * from "./ugc.js";
+export * from "./ugc-amplification-identity.js";
+export * from "./knowledge-repository.js";
+export * from "./knowledge-bases.js";

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

@@ -30,20 +30,27 @@ 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";
 export * from "./knowledge-bootstrap.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
+export * from "./knowledge-vault-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";
@@ -149,3 +156,6 @@ export function isVersionLess(a, b) {
     return compareSemver(a, b) < 0;
 }
 export * from "./ugc.js";
+export * from "./ugc-amplification-identity.js";
+export * from "./knowledge-repository.js";
+export * from "./knowledge-bases.js";

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

@@ -0,0 +1,74 @@
+export type KnowledgeBaseViewType = "table" | "cards" | "kanban";
+export type KnowledgeBaseFilter = string | {
+    and?: KnowledgeBaseFilter[];
+    or?: KnowledgeBaseFilter[];
+    not?: KnowledgeBaseFilter[];
+};
+export type KnowledgeBaseIssue = {
+    code: "invalid_base" | "unsupported_filter" | "unsupported_view" | "invalid_view";
+    message: string;
+    expression?: string;
+    view?: string;
+};
+export type KnowledgeBaseProperty = {
+    displayName?: string;
+    raw: Record<string, unknown>;
+};
+export type KnowledgeBaseView = {
+    type: string;
+    name: string;
+    groupBy?: {
+        property: string;
+        direction: "ASC" | "DESC";
+    };
+    order: string[];
+    boardColumns: string[];
+    cardTitleProperty?: string;
+    sort: Array<{
+        property: string;
+        direction: "ASC" | "DESC";
+    }>;
+    filters?: KnowledgeBaseFilter;
+    columnColors: Record<string, string>;
+    wipLimits: Record<string, number>;
+    raw: Record<string, unknown>;
+};
+export type KnowledgeBaseDefinition = {
+    path: string;
+    name: string;
+    filters?: KnowledgeBaseFilter;
+    properties: Record<string, KnowledgeBaseProperty>;
+    views: KnowledgeBaseView[];
+    raw: Record<string, unknown>;
+};
+export type KnowledgeBaseFile = {
+    id: string;
+    path: string;
+    body?: string;
+    properties: Record<string, unknown>;
+    revision: number;
+};
+export type KnowledgeBaseParseResult = {
+    definition: KnowledgeBaseDefinition | null;
+    issues: KnowledgeBaseIssue[];
+};
+export type KnowledgeBaseEvaluation = {
+    files: KnowledgeBaseFile[];
+    issues: KnowledgeBaseIssue[];
+};
+export type KnowledgeBaseGroup = {
+    key: string;
+    title: string;
+    files: KnowledgeBaseFile[];
+};
+export declare function parseKnowledgeBase(path: string, source: string): KnowledgeBaseParseResult;
+export declare function knowledgeBasePropertyKey(property: string): string;
+export declare function knowledgeBasePropertyValue(file: KnowledgeBaseFile, property: string): unknown;
+export declare function knowledgeBasePropertyText(file: KnowledgeBaseFile, property: string): string;
+export declare function evaluateKnowledgeBaseView(definition: KnowledgeBaseDefinition, view: KnowledgeBaseView, files: readonly KnowledgeBaseFile[]): KnowledgeBaseEvaluation;
+export declare function knowledgeBaseGroups(view: KnowledgeBaseView, files: readonly KnowledgeBaseFile[], configuredColumns?: readonly string[]): KnowledgeBaseGroup[];
+export declare function knowledgeBaseDisplayName(definition: KnowledgeBaseDefinition, property: string): string;
+export declare function knowledgeBaseCardTitle(file: KnowledgeBaseFile, view: KnowledgeBaseView): string;
+export declare function parseBaseBoardColumnOrder(value: unknown): Record<string, string[]>;
+/** Resolve Base Board's `<folder>::<view>::<property>` lane order, with view-name shorthand for API callers. */
+export declare function resolveBaseBoardColumnOrder(definition: KnowledgeBaseDefinition, view: KnowledgeBaseView, configured: Readonly<Record<string, readonly string[]>>): string[];