@oxygen-agent/cli 1.162.10 → 1.177.0

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

@@ -1,5 +1,29 @@
 const SECRET_KEY_PATTERN = /(api[_-]?key|x[_-]?key|authorization|bearer|cookie|password|secret|token|ciphertext|connection[_-]?string|connection[_-]?uri|database[_-]?url|dsn)/i;
 const OMITTED_KEY_PATTERN = /^(body|payload|prompt|prompts|raw_prompt|raw_prompts|row|rows|input|inputs|output|outputs|request|response|provider_payload|provider_response|customer_data)$/i;
+// OXY-125: keyed redaction (SECRET_KEY_PATTERN) only catches whole fields named
+// like a secret. Credentials also leak as *substrings* of otherwise-ordinary
+// fields — most commonly an Authorization header dumped into error_message /
+// error_stack. This matches the HTTP bearer scheme followed by its token (JWT /
+// base64 / opaque, including our `oxy_live_`/`oxy_sess_` prefixes) anywhere in a
+// string.
+const BEARER_TOKEN_PATTERN = /\bBearer\s+[\w.~+/=-]+/gi;
+// OXY-139: the prod log-hygiene sweep also flags `sk-…` API keys and DB
+// connection URLs that ride along inside ordinary (non-secret-named) fields, so
+// keyed + Bearer redaction is not enough. We scrub the two shapes that carry real
+// secret *material* as substrings of any value:
+//   • DB URLs — the whole `postgres(ql)://…` (incl. scheme) so the marker cannot
+//     re-trip the sweep's `postgres://[^ ]+` clause.
+//   • `sk-…` keys — body allowed to contain `_`/`-` and no word boundary, matching
+//     the sweep regex byte-for-byte. This also neutralises the OXY-139 false
+//     positive: a Vercel `x-vercel-id` whose first segment ends in `sk`
+//     (e.g. `2g5sk-1781047899561-…`, logged as request_id on every cron summary
+//     line) is not a credential but is sweep-shaped, so it must be redacted to
+//     clear the signal; trace_id stays intact as the correlation key.
+// The bare `OPENAI_API_KEY` *name* is deliberately NOT scrubbed — it is a variable
+// name, not a secret, and hiding it would suppress legitimate "OPENAI_API_KEY is
+// missing" diagnostics (its actual value is an `sk-…` string, already covered).
+const DB_URL_PATTERN = /(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|rediss?|amqps?):\/\/[^\s"'<>()]+/gi;
+const SK_TOKEN_PATTERN = /sk-[A-Za-z0-9_-]{20,}/g;
 const MAX_LOG_STRING_LENGTH = 8_000;
 const MAX_TELEMETRY_STRING_LENGTH = 500;
 const MAX_ARRAY_LENGTH = 20;
@@ -36,7 +60,7 @@ function sanitizeValueForLog(value, key, depth) {
     if (value === null || value === undefined)
         return value;
     if (typeof value === "string")
-        return truncateString(value, MAX_LOG_STRING_LENGTH);
+        return truncateString(redactSecretsInString(value), MAX_LOG_STRING_LENGTH);
     if (typeof value === "number")
         return Number.isFinite(value) ? value : null;
     if (typeof value === "boolean")
@@ -67,7 +91,7 @@ function normalizeTelemetryValue(value, key) {
     if (OMITTED_KEY_PATTERN.test(key))
         return "[omitted]";
     if (typeof value === "string")
-        return truncateString(value, MAX_TELEMETRY_STRING_LENGTH);
+        return truncateString(redactSecretsInString(value), MAX_TELEMETRY_STRING_LENGTH);
     if (typeof value === "number")
         return Number.isFinite(value) ? value : undefined;
     if (typeof value === "boolean")
@@ -80,8 +104,12 @@ function normalizeTelemetryValue(value, key) {
             .filter((entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean");
         if (primitive.length === 0)
             return undefined;
+        // Array elements need the same substring scrub as scalar strings: a string[]
+        // attribute (e.g. dumped header lines) carries the same Bearer/sk-/DB-URL
+        // material, and this branch was the one telemetry path that exported it
+        // verbatim. Redact before truncating so a cut cannot expose token material.
         if (primitive.every((entry) => typeof entry === "string")) {
-            return primitive.map((entry) => truncateString(String(entry), MAX_TELEMETRY_STRING_LENGTH));
+            return primitive.map((entry) => truncateString(redactSecretsInString(entry), MAX_TELEMETRY_STRING_LENGTH));
         }
         if (primitive.every((entry) => typeof entry === "number" && Number.isFinite(entry))) {
             return primitive;
@@ -89,7 +117,7 @@ function normalizeTelemetryValue(value, key) {
         if (primitive.every((entry) => typeof entry === "boolean")) {
             return primitive;
         }
-        return primitive.map((entry) => truncateString(String(entry), MAX_TELEMETRY_STRING_LENGTH));
+        return primitive.map((entry) => truncateString(redactSecretsInString(String(entry)), MAX_TELEMETRY_STRING_LENGTH));
     }
     if (typeof value === "object" && value) {
         return truncateString(JSON.stringify(sanitizeValueForLog(value, key, 0)), MAX_TELEMETRY_STRING_LENGTH);
@@ -100,6 +128,19 @@ function sanitizeAttributeKey(key) {
     const normalized = key.trim().replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 120);
     return normalized || null;
 }
+// Replaces credential-shaped substrings with token-free markers. Order matters:
+// Bearer first so an `Authorization: Bearer sk-…` header collapses to a single
+// `Bearer[REDACTED]` instead of leaving a stray `Bearer ` (the sweep matches
+// `Bearer ` with a trailing space). Each marker is chosen so a second pass — and
+// every prod-sweep regex (`Bearer `, `sk-…`, `postgres://…`) — finds nothing, so
+// redaction stays idempotent. Sharing the global regexes is safe because
+// String.replace resets their lastIndex between calls.
+function redactSecretsInString(value) {
+    return value
+        .replace(BEARER_TOKEN_PATTERN, "Bearer[REDACTED]")
+        .replace(DB_URL_PATTERN, "[REDACTED_DB_URL]")
+        .replace(SK_TOKEN_PATTERN, "[REDACTED_SK]");
+}
 function truncateString(value, maxLength) {
     return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
 }

package/node_modules/@oxygen/shared/dist/search-vocab.d.ts

@@ -0,0 +1,18 @@
+export declare function normalizeText(value: string): string;
+export declare function escapeRegExp(value: string): string;
+export declare function extractUrls(value: string): string[];
+export declare function extractDomains(value: string): string[];
+export declare function parseMoney(amount: string, unit: string | undefined): number;
+export declare function regionDisplayName(code: string): string | null;
+export declare const COUNTRY_NAME_TO_ISO: Map<string, string>;
+export declare const COUNTRY_ALIAS_TO_ISO: Record<string, string>;
+export declare const CITY_TO_ISO: Record<string, string>;
+export declare const KNOWN_TECHNOLOGIES: readonly ["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"];
+export declare const INDUSTRY_TERMS: readonly ["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 declare const EMPLOYEE_SEGMENTS: Record<string, {
+    min?: number;
+    max?: number;
+}>;
+export declare const KEYWORD_STOPWORDS: Set<string>;
+export declare const DEPARTMENT_TERMS: Record<string, string>;
+export declare const SENIORITY_TERMS: Record<string, string>;

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;