@oxygen-agent/cli 1.164.30 → 1.177.1

package/node_modules/@oxygen/shared/dist/search-vocab.js

@@ -0,0 +1,151 @@
+// Shared search-planner vocabulary + stateless text helpers.
+//
+// Single source of truth for the constraint vocabulary and pure text helpers
+// consumed by BOTH the legacy web search planners
+// (apps/web/src/lib/company-search-plan.ts, people-search-plan.ts) and the
+// @oxygen/routing classifier/compiler (via packages/routing/src/vocab.ts,
+// which layers its named tuning deltas on top of these bases). Keeping one copy
+// here is what stops the two surfaces from silently drifting (OXY-414).
+//
+// Everything here is a pure function or a static table: no Date.now, no
+// randomness, no I/O — safe to import from any layer.
+export function normalizeText(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function extractUrls(value) {
+    return [...new Set((value.match(/https?:\/\/[^\s)]+/gi) ?? []).map((url) => url.replace(/[.,;]+$/, "")))];
+}
+export function extractDomains(value) {
+    const domains = value.match(/\b(?:[a-z0-9-]+\.)+[a-z]{2,}\b/gi) ?? [];
+    return [...new Set(domains.map((domain) => domain.toLowerCase()).filter((domain) => !domain.includes("@")))];
+}
+export function parseMoney(amount, unit) {
+    const value = Number(amount);
+    const normalized = (unit ?? "").toLowerCase();
+    if (normalized.startsWith("b"))
+        return Math.round(value * 1_000_000_000);
+    if (normalized.startsWith("m"))
+        return Math.round(value * 1_000_000);
+    if (normalized.startsWith("k"))
+        return Math.round(value * 1_000);
+    return Math.round(value);
+}
+// ISO 3166-1 alpha-2 handling is backed by the platform's Intl region data instead of
+// a hardcoded country table, so every assigned code validates and renders a display name.
+const REGION_DISPLAY = new Intl.DisplayNames(["en"], { type: "region" });
+export function regionDisplayName(code) {
+    if (!/^[A-Z]{2}$/.test(code))
+        return null;
+    try {
+        const name = REGION_DISPLAY.of(code);
+        return name && name !== code ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Lowercased country display name -> ISO code, generated from Intl region data at module load.
+export const COUNTRY_NAME_TO_ISO = (() => {
+    const map = new Map();
+    for (let first = 65; first <= 90; first += 1) {
+        for (let second = 65; second <= 90; second += 1) {
+            const code = String.fromCharCode(first) + String.fromCharCode(second);
+            const name = regionDisplayName(code);
+            if (name)
+                map.set(name.toLowerCase(), code);
+        }
+    }
+    return map;
+})();
+// Common aliases and demonyms that Intl display names do not cover. Keys are lowercase prompt phrases.
+export const COUNTRY_ALIAS_TO_ISO = {
+    "usa": "US", "u.s.": "US", "u.s.a.": "US", "us": "US", "america": "US", "american": "US", "the states": "US",
+    "uk": "GB", "u.k.": "GB", "britain": "GB", "great britain": "GB", "british": "GB", "england": "GB",
+    "german": "DE", "french": "FR", "dutch": "NL", "the netherlands": "NL", "holland": "NL",
+    "canadian": "CA", "australian": "AU", "austrian": "AT", "swiss": "CH", "swedish": "SE", "danish": "DK",
+    "norwegian": "NO", "finnish": "FI", "spanish": "ES", "italian": "IT", "portuguese": "PT", "polish": "PL",
+    "irish": "IE", "belgian": "BE", "brazilian": "BR", "mexican": "MX", "indian": "IN", "japanese": "JP",
+    "korean": "KR", "south korean": "KR", "chinese": "CN", "singaporean": "SG", "israeli": "IL",
+    "emirati": "AE", "uae": "AE", "saudi": "SA", "south african": "ZA", "nordic": "SE", "scandinavian": "SE",
+};
+// Major business-hub cities -> country code, used as geo hints when no country is named.
+export const CITY_TO_ISO = {
+    "san francisco": "US", "new york": "US", "nyc": "US", "boston": "US", "austin": "US", "seattle": "US",
+    "los angeles": "US", "chicago": "US", "miami": "US", "denver": "US", "atlanta": "US",
+    "london": "GB", "manchester": "GB", "berlin": "DE", "munich": "DE", "hamburg": "DE", "cologne": "DE",
+    "paris": "FR", "amsterdam": "NL", "rotterdam": "NL", "stockholm": "SE", "copenhagen": "DK", "oslo": "NO",
+    "helsinki": "FI", "zurich": "CH", "geneva": "CH", "vienna": "AT", "madrid": "ES", "barcelona": "ES",
+    "milan": "IT", "lisbon": "PT", "dublin": "IE", "brussels": "BE", "warsaw": "PL", "toronto": "CA",
+    "vancouver": "CA", "montreal": "CA", "sydney": "AU", "melbourne": "AU", "singapore": "SG",
+    "tokyo": "JP", "tel aviv": "IL", "dubai": "AE", "bangalore": "IN", "mumbai": "IN", "sao paulo": "BR",
+};
+// Common B2B technologies recognized at query time. Unrecognized "using <X>" phrases become unparsed hints.
+export const KNOWN_TECHNOLOGIES = [
+    "salesforce", "hubspot", "shopify", "stripe", "aws", "azure", "gcp", "google cloud", "snowflake",
+    "databricks", "postgres", "postgresql", "mysql", "mongodb", "redis", "kafka", "kubernetes", "docker",
+    "react", "nextjs", "next.js", "vue", "angular", "node", "python", "ruby on rails", "django",
+    "segment", "amplitude", "mixpanel", "intercom", "zendesk", "marketo", "pardot", "outreach",
+    "salesloft", "gong", "clari", "netsuite", "workday", "sap", "oracle", "twilio", "klaviyo", "webflow",
+    "wordpress", "magento", "bigcommerce", "woocommerce",
+];
+// Industry-ish terms that go to both keywords and industries (provider enum resolution is reported separately).
+export const INDUSTRY_TERMS = [
+    "saas", "b2b saas", "fintech", "healthtech", "healthcare", "edtech", "martech", "adtech", "proptech",
+    "insurtech", "legaltech", "hrtech", "regtech", "biotech", "medtech", "cleantech", "climate tech",
+    "cybersecurity", "security", "devtools", "developer tools", "e-commerce", "ecommerce", "logistics",
+    "supply chain", "manufacturing", "construction", "real estate", "hospitality", "retail", "gaming",
+    "media", "telecom", "automotive", "aerospace", "agritech", "foodtech", "ai", "artificial intelligence",
+    "machine learning", "data analytics", "consulting", "staffing", "recruiting",
+];
+export const EMPLOYEE_SEGMENTS = {
+    "smb": { min: 1, max: 200 },
+    "small business": { min: 1, max: 200 },
+    "small businesses": { min: 1, max: 200 },
+    "mid-market": { min: 50, max: 1000 },
+    "mid market": { min: 50, max: 1000 },
+    "midmarket": { min: 50, max: 1000 },
+    "enterprise": { min: 1000 },
+    "enterprises": { min: 1000 },
+    "startup": { min: 1, max: 50 },
+    "startups": { min: 1, max: 50 },
+    "scaleup": { min: 50, max: 500 },
+    "scaleups": { min: 50, max: 500 },
+};
+// Words to drop when harvesting free-text keyword phrases (geo/size words are captured by dedicated extractors).
+export const KEYWORD_STOPWORDS = new Set([
+    "find", "source", "build", "list", "of", "for", "the", "a", "an", "top", "best", "new", "all", "some",
+    "more", "with", "and", "or", "in", "at", "us", "uk", "eu", "based", "headquartered", "located",
+    "small", "large", "mid-market", "enterprise", "smb", "startup", "early-stage", "growth-stage",
+]);
+// Department phrase -> canonical department label (people search).
+export const DEPARTMENT_TERMS = {
+    sales: "Sales",
+    marketing: "Marketing",
+    engineering: "Engineering",
+    product: "Product",
+    finance: "Finance",
+    "human resources": "Human Resources",
+    "people ops": "Human Resources",
+    recruiting: "Human Resources",
+    operations: "Operations",
+    revops: "Revenue Operations",
+    "revenue operations": "Revenue Operations",
+    "customer success": "Customer Success",
+    support: "Customer Success",
+    legal: "Legal",
+    it: "Information Technology",
+    security: "Information Technology",
+    data: "Data",
+    design: "Design",
+};
+// Seniority phrase -> canonical seniority band (people search).
+export const SENIORITY_TERMS = {
+    "c-suite": "C-Suite", "c-level": "C-Suite", chief: "C-Suite", founder: "C-Suite", ceo: "C-Suite",
+    cto: "C-Suite", cfo: "C-Suite", coo: "C-Suite", cmo: "C-Suite", cro: "C-Suite", president: "C-Suite",
+    vp: "VP", "vice president": "VP", svp: "VP", evp: "VP",
+    director: "Director", "head of": "Director",
+    manager: "Manager", lead: "Manager", principal: "Manager",
+};

package/node_modules/@oxygen/shared/dist/select-options.d.ts

@@ -0,0 +1,18 @@
+export declare const TAG_COLORS: readonly ["gray", "red", "orange", "amber", "yellow", "green", "teal", "blue", "indigo", "purple", "pink"];
+export type TagColor = (typeof TAG_COLORS)[number];
+export declare const DEFAULT_TAG_COLOR: TagColor;
+export declare function isTagColor(value: unknown): value is TagColor;
+export declare function tagColorForIndex(index: number): TagColor;
+export declare const SELECT_COLUMN_SEMANTICS: readonly ["select", "single_select", "multi_select", "tags", "status"];
+export type SelectColumnSemantic = (typeof SELECT_COLUMN_SEMANTICS)[number];
+export declare function isSelectColumnSemantic(semanticType: string | null | undefined): boolean;
+export declare function isMultiSelectSemantic(semanticType: string | null | undefined): boolean;
+export declare function isStatusSemantic(semanticType: string | null | undefined): boolean;
+export type SelectOption = {
+    id: string;
+    value: string;
+    label: string;
+    color: TagColor;
+    order: number;
+};
+export declare function normalizeSelectOptions(raw: unknown): SelectOption[];

package/node_modules/@oxygen/shared/dist/select-options.js

@@ -0,0 +1,121 @@
+// Canonical colored option model for select / multi-select / status columns.
+//
+// Shared across server validation, the web option editor, colored-pill
+// rendering, filters, and the kanban view so every surface agrees. Colors are
+// NAMED (theme-safe), stored once on the option — never raw hex — mirroring how
+// Attio/Notion model status & select option colors.
+export const TAG_COLORS = [
+    "gray",
+    "red",
+    "orange",
+    "amber",
+    "yellow",
+    "green",
+    "teal",
+    "blue",
+    "indigo",
+    "purple",
+    "pink",
+];
+export const DEFAULT_TAG_COLOR = "gray";
+export function isTagColor(value) {
+    return typeof value === "string" && TAG_COLORS.includes(value);
+}
+// Auto-assign colors for fresh options, skipping gray so a new column looks
+// colorful out of the box; gray stays a deliberate manual choice.
+export function tagColorForIndex(index) {
+    const palette = TAG_COLORS.filter((color) => color !== "gray");
+    return palette[Math.abs(index) % palette.length] ?? DEFAULT_TAG_COLOR;
+}
+// Semantic types (the column's `semanticType`) that present a fixed option set.
+// `select`/`status` are single-value; `multi_select`/`tags` are array-valued.
+// `single_select` is accepted as an alias of `select`.
+export const SELECT_COLUMN_SEMANTICS = [
+    "select",
+    "single_select",
+    "multi_select",
+    "tags",
+    "status",
+];
+export function isSelectColumnSemantic(semanticType) {
+    return Boolean(semanticType) && SELECT_COLUMN_SEMANTICS.includes(semanticType);
+}
+export function isMultiSelectSemantic(semanticType) {
+    return semanticType === "multi_select" || semanticType === "tags";
+}
+export function isStatusSemantic(semanticType) {
+    return semanticType === "status";
+}
+const MAX_OPTIONS = 200;
+// Normalize a raw options array (from a column `definition.options`, CLI/MCP, or
+// the editor) into canonical SelectOptions: dedupe by value, default colors,
+// canonical 0..n ordering. Accepts strings or {value,label,color,order} objects.
+export function normalizeSelectOptions(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const seen = new Set();
+    const collected = [];
+    for (const entry of raw) {
+        const option = normalizeSelectOption(entry, collected.length);
+        if (!option)
+            continue;
+        const dedupeKey = option.value.toLowerCase();
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        collected.push(option);
+        if (collected.length >= MAX_OPTIONS)
+            break;
+    }
+    collected.sort((a, b) => a.order - b.order);
+    return collected.map((option, index) => ({ ...option, order: index }));
+}
+function normalizeSelectOption(entry, fallbackIndex) {
+    if (typeof entry === "string")
+        return optionFromString(entry, fallbackIndex);
+    if (!entry || typeof entry !== "object")
+        return null;
+    const record = entry;
+    const rawValue = readOptionValue(record);
+    if (!rawValue)
+        return null;
+    const label = readTrimmedString(record.label) ?? rawValue;
+    const id = readTrimmedString(record.id) ?? slugifyOption(rawValue);
+    const color = isTagColor(record.color) ? record.color : tagColorForIndex(fallbackIndex);
+    const order = typeof record.order === "number" && Number.isFinite(record.order) ? record.order : fallbackIndex;
+    return { id, value: rawValue, label, color, order };
+}
+// A bare string entry becomes a fully-defaulted option (value == label == the
+// trimmed string); blank strings are dropped.
+function optionFromString(entry, fallbackIndex) {
+    const value = entry.trim();
+    if (!value)
+        return null;
+    return {
+        id: slugifyOption(value),
+        value,
+        label: value,
+        color: tagColorForIndex(fallbackIndex),
+        order: fallbackIndex,
+    };
+}
+// The cell value comes from `value`, falling back to `label`; "" when neither is
+// a non-blank string (so the caller drops the option).
+function readOptionValue(record) {
+    return readTrimmedString(record.value) ?? readTrimmedString(record.label) ?? "";
+}
+// Returns the trimmed string when the field is a non-blank string, else null.
+function readTrimmedString(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+}
+function slugifyOption(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 60);
+    return slug || "option";
+}

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

@@ -1,4 +1,4 @@
-import { OxygenError } from "./index.js";
+import { OxygenError } from "./cli-result.js";
 import { renderLinkedInTemplate } from "./linkedin-sequences.js";
 /**
  * Multichannel sequence DSL — the shared contract validated identically by CLI,

package/node_modules/@oxygen/shared/dist/sql-error.d.ts

@@ -21,12 +21,6 @@ export type SqlErrorAttribution = {
     /** Neon/HTTP transport status code (numeric) when the failure carries one. */
     statusCode: number | null;
 };
-/**
- * Classifies a pg/drizzle error into structured, non-secret attribution.
- * Returns null when the error carries no SQL/connection signal at all (so
- * non-DB errors never gain spurious `db.*` attributes). Never throws.
- */
-export declare function describeSqlError(error: unknown): SqlErrorAttribution | null;
 /** Log-field shape (snake_case) for merging into `errorFields(error)` payloads. */
 export declare function sqlErrorFields(error: unknown): Record<string, unknown>;
 /**

package/node_modules/@oxygen/shared/dist/sql-error.js

@@ -68,23 +68,14 @@ const TRANSIENT_CAUSES = new Set([
  * Returns null when the error carries no SQL/connection signal at all (so
  * non-DB errors never gain spurious `db.*` attributes). Never throws.
  */
-export function describeSqlError(error) {
+function describeSqlError(error) {
     try {
         const sqlstate = readSqlstate(error);
         const errno = readErrno(error);
         const message = readMessage(error);
         const drizzle = isDrizzleQueryError(error, message);
-        let cause = sqlstate ? categoryFromSqlstate(sqlstate) ?? "unknown" : "unknown";
-        if (cause === "unknown") {
-            if (errno && CONNECT_TIMEOUT_ERRNOS.has(errno))
-                cause = "connect_timeout";
-            else if (errno && CONNECTION_ERRNOS.has(errno))
-                cause = "connection";
-            else if (CONNECT_TIMEOUT_MESSAGE.test(message))
-                cause = "connect_timeout";
-            else if (CONNECTION_MESSAGE.test(message))
-                cause = "connection";
-        }
+        const sqlstateCause = sqlstate ? categoryFromSqlstate(sqlstate) ?? "unknown" : "unknown";
+        const cause = sqlstateCause !== "unknown" ? sqlstateCause : causeFromErrnoOrMessage(errno, message);
         const hasSignal = Boolean(sqlstate) || Boolean(errno) || cause !== "unknown" || drizzle;
         if (!hasSignal)
             return null;
@@ -110,22 +101,35 @@ export function describeSqlError(error) {
         return null;
     }
 }
+// Connection-level fallback when no SQLSTATE resolved a cause: prefer the
+// errno (set before/around the TCP+TLS handshake), then the message text.
+function causeFromErrnoOrMessage(errno, message) {
+    if (errno && CONNECT_TIMEOUT_ERRNOS.has(errno))
+        return "connect_timeout";
+    if (errno && CONNECTION_ERRNOS.has(errno))
+        return "connection";
+    if (CONNECT_TIMEOUT_MESSAGE.test(message))
+        return "connect_timeout";
+    if (CONNECTION_MESSAGE.test(message))
+        return "connection";
+    return "unknown";
+}
 /** Log-field shape (snake_case) for merging into `errorFields(error)` payloads. */
 export function sqlErrorFields(error) {
-    const a = describeSqlError(error);
-    if (!a)
+    const attribution = describeSqlError(error);
+    if (!attribution)
         return {};
     return {
-        ...(a.pgCode ? { sql_error_pg_code: a.pgCode } : {}),
-        sql_error_cause: a.cause,
-        ...(a.queryKind ? { sql_error_query_kind: a.queryKind } : {}),
-        ...(a.table ? { sql_error_table: a.table } : {}),
-        sql_error_transient: a.transient,
-        ...(a.severity ? { sql_error_severity: a.severity } : {}),
-        ...(a.schema ? { sql_error_schema: a.schema } : {}),
-        ...(a.column ? { sql_error_column: a.column } : {}),
-        ...(a.constraint ? { sql_error_constraint: a.constraint } : {}),
-        ...(a.statusCode !== null ? { sql_error_status: a.statusCode } : {}),
+        ...(attribution.pgCode ? { sql_error_pg_code: attribution.pgCode } : {}),
+        sql_error_cause: attribution.cause,
+        ...(attribution.queryKind ? { sql_error_query_kind: attribution.queryKind } : {}),
+        ...(attribution.table ? { sql_error_table: attribution.table } : {}),
+        sql_error_transient: attribution.transient,
+        ...(attribution.severity ? { sql_error_severity: attribution.severity } : {}),
+        ...(attribution.schema ? { sql_error_schema: attribution.schema } : {}),
+        ...(attribution.column ? { sql_error_column: attribution.column } : {}),
+        ...(attribution.constraint ? { sql_error_constraint: attribution.constraint } : {}),
+        ...(attribution.statusCode !== null ? { sql_error_status: attribution.statusCode } : {}),
     };
 }
 /**
@@ -144,47 +148,52 @@ export function redactSqlParameters(text) {
 }
 /** Telemetry-attribute shape (dotted keys) for span error attribution. */
 export function sqlErrorTelemetryAttributes(error) {
-    const a = describeSqlError(error);
-    if (!a)
+    const attribution = describeSqlError(error);
+    if (!attribution)
         return {};
     return {
-        ...(a.pgCode ? { "db.pg_code": a.pgCode } : {}),
-        "db.error.cause": a.cause,
-        ...(a.queryKind ? { "db.error.query_kind": a.queryKind } : {}),
-        ...(a.table ? { "db.error.table": a.table } : {}),
-        "db.error.transient": a.transient,
-        ...(a.severity ? { "db.error.severity": a.severity } : {}),
-        ...(a.schema ? { "db.error.schema": a.schema } : {}),
-        ...(a.column ? { "db.error.column": a.column } : {}),
-        ...(a.constraint ? { "db.error.constraint": a.constraint } : {}),
-        ...(a.statusCode !== null ? { "db.error.status": a.statusCode } : {}),
+        ...(attribution.pgCode ? { "db.pg_code": attribution.pgCode } : {}),
+        "db.error.cause": attribution.cause,
+        ...(attribution.queryKind ? { "db.error.query_kind": attribution.queryKind } : {}),
+        ...(attribution.table ? { "db.error.table": attribution.table } : {}),
+        "db.error.transient": attribution.transient,
+        ...(attribution.severity ? { "db.error.severity": attribution.severity } : {}),
+        ...(attribution.schema ? { "db.error.schema": attribution.schema } : {}),
+        ...(attribution.column ? { "db.error.column": attribution.column } : {}),
+        ...(attribution.constraint ? { "db.error.constraint": attribution.constraint } : {}),
+        ...(attribution.statusCode !== null ? { "db.error.status": attribution.statusCode } : {}),
     };
 }
+// Specific SQLSTATEs that must resolve before the coarser class-prefix lookup
+// (e.g. 40001 serialization / 40P01 deadlock are more precise than class 40).
+const EXACT_SQLSTATE_CAUSES = new Map([
+    ["57014", "statement_timeout"],
+    ["53300", "too_many_connections"],
+    ["40001", "serialization"],
+    ["40P01", "deadlock"],
+]);
+// SQLSTATE class (first two chars) → cause, applied only after the exact and
+// schema-drift lookups above so the precise codes keep their dedicated cause.
+const SQLSTATE_CLASS_CAUSES = new Map([
+    ["08", "connection"],
+    ["28", "auth"],
+    ["22", "data_exception"],
+    ["23", "integrity_constraint"],
+    ["40", "transaction_rollback"],
+    ["42", "syntax_or_access"],
+    ["53", "insufficient_resources"],
+    ["57", "admin_shutdown"],
+    ["58", "internal"],
+    ["XX", "internal"],
+    ["3F", "schema_drift"],
+]);
 function categoryFromSqlstate(code) {
-    if (code === "57014")
-        return "statement_timeout";
-    if (code === "53300")
-        return "too_many_connections";
-    if (code === "40001")
-        return "serialization";
-    if (code === "40P01")
-        return "deadlock";
+    const exact = EXACT_SQLSTATE_CAUSES.get(code);
+    if (exact)
+        return exact;
     if (SCHEMA_DRIFT_SQLSTATES.has(code))
         return "schema_drift";
-    switch (code.slice(0, 2)) {
-        case "08": return "connection";
-        case "28": return "auth";
-        case "22": return "data_exception";
-        case "23": return "integrity_constraint";
-        case "40": return "transaction_rollback";
-        case "42": return "syntax_or_access";
-        case "53": return "insufficient_resources";
-        case "57": return "admin_shutdown";
-        case "58": return "internal";
-        case "XX": return "internal";
-        case "3F": return "schema_drift";
-        default: return null;
-    }
+    return SQLSTATE_CLASS_CAUSES.get(code.slice(0, 2)) ?? null;
 }
 // Walk the Error.cause chain (bounded) and return the first non-null value the
 // reader extracts. drizzle wraps the pg error on `.cause`, and custom wrappers

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

@@ -5,7 +5,6 @@ export type WithTelemetrySpanOptions = {
 export declare function withTelemetrySpan<T>(tracerName: string, name: string, attributes: TelemetryAttributes | undefined, fn: () => Promise<T>, options?: WithTelemetrySpanOptions): Promise<T>;
 export declare function setActiveTelemetryAttributes(attributes: TelemetryAttributes): void;
 export declare function markActiveTelemetryError(message: string, attributes?: TelemetryAttributes): void;
-export declare function addTelemetryEvent(name: string, attributes?: TelemetryAttributes): void;
 export declare function recordTelemetryCounter(name: string, value?: number, attributes?: TelemetryAttributes): void;
 export declare function recordTelemetryHistogram(name: string, value: number, attributes?: TelemetryAttributes): void;
 export declare function commonTelemetryAttributes(attributes?: TelemetryAttributes): TelemetryAttributes;

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

@@ -5,6 +5,8 @@ import { redactSqlParameters, sqlErrorTelemetryAttributes } from "./sql-error.js
 import { OXYGEN_VERSION } from "./version.js";
 const counterCache = new Map();
 const histogramCache = new Map();
+// skipcq: JS-0116 — `async` keeps synchronous setup throws (getTracer / attribute
+// normalization) as rejections so the Promise<T> contract holds for all callers.
 export async function withTelemetrySpan(tracerName, name, attributes, fn, options) {
     const tracer = trace.getTracer(tracerName, OXYGEN_VERSION);
     return tracer.startActiveSpan(name, { attributes: normalizeTelemetryAttributes(commonTelemetryAttributes(attributes)) }, async (span) => {
@@ -51,12 +53,6 @@ export function markActiveTelemetryError(message, attributes) {
         span.setAttributes(normalizeTelemetryAttributes(attributes));
     }
 }
-export function addTelemetryEvent(name, attributes) {
-    const span = trace.getActiveSpan();
-    if (!span)
-        return;
-    span.addEvent(name, normalizeTelemetryAttributes(attributes));
-}
 export function recordTelemetryCounter(name, value = 1, attributes) {
     if (!Number.isFinite(value))
         return;
@@ -71,28 +67,37 @@ export function recordTelemetryHistogram(name, value, attributes) {
 }
 export function commonTelemetryAttributes(attributes) {
     const workerProcess = isWorkerProcess();
+    // Each attribute reads an ordered env-var fallback chain that differs by
+    // surface: the worker prefers its Fly vars first, the web its Vercel vars.
+    // pickEnvBySurface picks the surface's list, then the first defined value.
+    const pick = (workerKeys, webKeys) => pickEnvBySurface(workerProcess, workerKeys, webKeys);
     return {
         "oxygen.version": OXYGEN_VERSION,
-        "deployment.environment": workerProcess
-            ? process.env.FLY_ENVIRONMENT ?? process.env.NODE_ENV ?? null
-            : process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? null,
+        "deployment.environment": pick(["FLY_ENVIRONMENT", "NODE_ENV"], ["VERCEL_ENV", "NODE_ENV"]),
         // deployment.sha stays the deploy artifact id: the Fly registry image ref on
         // the worker (release cross-reference), VERCEL_GIT_COMMIT_SHA on the web. The
         // worker's image ref is NOT a git commit, so deployment.git_sha carries the
         // resolved commit separately and is the single field that means "the commit"
         // on both surfaces (OXY-61). On the web both happen to equal the Vercel SHA.
-        "deployment.sha": workerProcess
-            ? process.env.FLY_IMAGE_REF ?? process.env.VERCEL_GIT_COMMIT_SHA ?? null
-            : process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.FLY_IMAGE_REF ?? null,
-        "deployment.git_sha": workerProcess
-            ? process.env.OXYGEN_GIT_SHA ?? process.env.VERCEL_GIT_COMMIT_SHA ?? null
-            : process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.OXYGEN_GIT_SHA ?? null,
-        "cloud.region": workerProcess
-            ? process.env.FLY_REGION ?? process.env.VERCEL_REGION ?? null
-            : process.env.VERCEL_REGION ?? process.env.FLY_REGION ?? null,
+        "deployment.sha": pick(["FLY_IMAGE_REF", "VERCEL_GIT_COMMIT_SHA"], ["VERCEL_GIT_COMMIT_SHA", "FLY_IMAGE_REF"]),
+        "deployment.git_sha": pick(["OXYGEN_GIT_SHA", "VERCEL_GIT_COMMIT_SHA"], ["VERCEL_GIT_COMMIT_SHA", "OXYGEN_GIT_SHA"]),
+        "cloud.region": pick(["FLY_REGION", "VERCEL_REGION"], ["VERCEL_REGION", "FLY_REGION"]),
         ...attributes,
     };
 }
+// Picks the env-var fallback list for the active surface (worker vs web), then
+// returns the first env var in that list that is set, else null. Preserves the
+// original `a ?? b ?? null` semantics exactly: only an unset (`undefined`) env
+// var falls through to the next key — an explicit empty string is kept.
+function pickEnvBySurface(workerProcess, workerKeys, webKeys) {
+    const keys = workerProcess ? workerKeys : webKeys;
+    for (const key of keys) {
+        const value = process.env[key];
+        if (value !== undefined)
+            return value;
+    }
+    return null;
+}
 function isWorkerProcess() {
     if (process.env.OXYGEN_PROCESS_ROLE === "worker")
         return true;

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

@@ -1,2 +1,2 @@
-export declare const OXYGEN_VERSION = "1.164.30";
+export declare const OXYGEN_VERSION = "1.177.1";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.154.0";

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

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.164.30";
+export const OXYGEN_VERSION = "1.177.1";
 // Bump this only when deployed CLI/API contracts require a newer CLI.
 // 1.154.0: LinkedIn → Sequencer rename moved the CLI/API/MCP surface
 // (oxygen sequences|inbox|senders, /api/cli/{sequences,inbox,senders}) and

package/node_modules/@oxygen/shared/dist/worker-failures-queue.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Canonical queue selector for the worker-failures surface, shared by:
+ *  - CLI `oxygen worker failures --queue <queue>` (free-text, passed through),
+ *  - MCP `oxygen_worker_failures({ queue })` (enum-constrained), and
+ *  - the `/api/cli/worker/failures` route that actually parses the value.
+ *
+ * Single-sourced so a token documented by one surface can never silently fall
+ * back to the `all` aggregate on another — the exact drift OXY-337 fixed, where
+ * the CLI documented `postgres_jobs` but the route only accepted `postgres_queue`.
+ */
+/**
+ * Public, documented queue tokens in display order. `postgres_queue` is the
+ * canonical name for the Postgres-backed background job queue. The MCP enum is
+ * built from this list so the constraint can never drift from the parser.
+ */
+export declare const WORKER_FAILURES_QUEUE_VALUES: readonly ["all", "actions", "ingestions", "postgres_queue"];
+export type WorkerFailuresQueue = (typeof WORKER_FAILURES_QUEUE_VALUES)[number];
+/**
+ * Normalize a raw `--queue` / `queue` value to its canonical token. Empty,
+ * missing, or unrecognized values resolve to `all` (the aggregate default).
+ */
+export declare function normalizeWorkerFailuresQueue(value: string | null | undefined): WorkerFailuresQueue;

package/node_modules/@oxygen/shared/dist/worker-failures-queue.js

@@ -0,0 +1,56 @@
+/**
+ * Canonical queue selector for the worker-failures surface, shared by:
+ *  - CLI `oxygen worker failures --queue <queue>` (free-text, passed through),
+ *  - MCP `oxygen_worker_failures({ queue })` (enum-constrained), and
+ *  - the `/api/cli/worker/failures` route that actually parses the value.
+ *
+ * Single-sourced so a token documented by one surface can never silently fall
+ * back to the `all` aggregate on another — the exact drift OXY-337 fixed, where
+ * the CLI documented `postgres_jobs` but the route only accepted `postgres_queue`.
+ */
+/**
+ * Public, documented queue tokens in display order. `postgres_queue` is the
+ * canonical name for the Postgres-backed background job queue. The MCP enum is
+ * built from this list so the constraint can never drift from the parser.
+ */
+export const WORKER_FAILURES_QUEUE_VALUES = [
+    "all",
+    "actions",
+    "ingestions",
+    "postgres_queue",
+];
+/**
+ * Every accepted token mapped to its canonical value. Covers the canonical
+ * tokens themselves plus legacy/compat aliases:
+ *  - `postgres_jobs` was the CLI-documented token before this unification.
+ *  - `bullmq` / `redis` / `jobs` predate the Postgres-queue migration.
+ *  - `postgres` / `pg` and the singular `action` / `ingestion` are shorthands.
+ */
+const QUEUE_TOKEN_TO_CANONICAL = {
+    all: "all",
+    action: "actions",
+    actions: "actions",
+    table_actions: "actions",
+    ingestion: "ingestions",
+    ingestions: "ingestions",
+    table_ingestions: "ingestions",
+    postgres: "postgres_queue",
+    postgres_queue: "postgres_queue",
+    postgres_jobs: "postgres_queue",
+    pg: "postgres_queue",
+    bullmq: "postgres_queue",
+    redis: "postgres_queue",
+    jobs: "postgres_queue",
+};
+/**
+ * Normalize a raw `--queue` / `queue` value to its canonical token. Empty,
+ * missing, or unrecognized values resolve to `all` (the aggregate default).
+ */
+export function normalizeWorkerFailuresQueue(value) {
+    if (!value)
+        return "all";
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return "all";
+    return QUEUE_TOKEN_TO_CANONICAL[normalized] ?? "all";
+}