@oxygen-agent/cli 1.1003.12 → 1.1010.644

package/node_modules/@oxygen/shared/dist/otlp-log-sink.d.ts

@@ -1,4 +1,4 @@
-import type { LogSink } from "./log.js";
+import { type LogLevel, type LogSink } from "./log.js";
 /**
  * Ships `log()` records to an OTLP/HTTP logs receiver (the self-hosted SigNoz
  * collector) instead of — or alongside — Axiom.
@@ -19,9 +19,16 @@ import type { LogSink } from "./log.js";
  * inside `log()`, so it must never await, throw, or block), the queue drops the
  * OLDEST record on overflow because the newest lines describe the incident being
  * debugged, and a collector outage is a dropped batch rather than a process
- * failure. Failures are written to stderr directly and at most once per flush
- * window — reporting them through `log()` would feed this sink its own error
- * line and recurse.
+ * failure. Failures and queue overflow are reported through `log()`, at most
+ * once per minute each whatever the flush interval (a dead collector behind a
+ * 2 s flush would otherwise write ~43k lines a day into Axiom), with the
+ * failures and drops a suppressed report would have carried accumulated into
+ * the next one, under the re-entrancy guard the Axiom shippers use
+ * (`emittingInternal`): this sink skips the records it emits itself, so a broken
+ * collector cannot feed its own failure line back into its queue, while every
+ * sink composed beside it (Axiom under `OXYGEN_LOG_SINK=both`) and stdout still
+ * receive the line. `log()` always writes stdout before it calls a sink, which
+ * is why the former direct stderr write is not kept as a fallback.
  */
 export type OtlpLogSinkOptions = {
     /** Full receiver URL, e.g. `http://collector.internal:4318/v1/logs`. */
@@ -36,6 +43,14 @@ export type OtlpLogSinkOptions = {
     /** `0` disables the interval timer, for runtimes that flush off a request lifecycle. */
     flushIntervalMs?: number | undefined;
     maxQueue?: number | undefined;
+    /** Clock for the report throttle; tests only. */
+    now?: (() => number) | undefined;
+    /**
+     * Lowest level this sink ships; records below it never enter the queue. Null
+     * or absent ships every level. Sinks composed beside this one (Axiom) and
+     * stdout are unaffected; see `resolveOtlpLogMinLevel`.
+     */
+    minLevel?: LogLevel | null | undefined;
     fetch?: typeof globalThis.fetch | undefined;
 };
 export type OtlpLogSinkHandle = {
@@ -43,6 +58,16 @@ export type OtlpLogSinkHandle = {
     flush: () => Promise<void>;
     stop: () => Promise<void>;
 };
+/**
+ * Reads `OXYGEN_LOG_OTLP_MIN_LEVEL` (debug|info|warn|error, case-insensitive).
+ *
+ * The OTLP collector is the one transport a noisy tier can drown, so it alone
+ * gets a floor; Axiom and stdout keep every level. Unset ships everything, which
+ * is the behaviour before the variable existed. An unrecognised value is named
+ * through `log()` and treated as unset: dropping more than was asked is the
+ * failure an operator cannot see, so a typo errs toward shipping.
+ */
+export declare function resolveOtlpLogMinLevel(env?: NodeJS.ProcessEnv): LogLevel | null;
 /**
  * `k=v,k=v` — the same shape as `OTEL_EXPORTER_OTLP_HEADERS`, so an operator who
  * knows the OTel variable can set ours without learning a second syntax. A pair

package/node_modules/@oxygen/shared/dist/otlp-log-sink.js

@@ -1,14 +1,86 @@
+import { log } from "./log.js";
+import { resolveDeployEnv } from "./deploy-env.js";
+import { sanitizeLogFields } from "./redaction.js";
+import { trace } from "@opentelemetry/api";
+import { operationalLogSnapshot } from "./operational-telemetry.js";
+import { telemetryEndpointForLog } from "./telemetry-export-observer.js";
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 2_000;
 const DEFAULT_MAX_QUEUE = 10_000;
 const EXPORT_TIMEOUT_MS = 10_000;
-const NO_TIMER_REPORT_WINDOW_MS = 60_000;
-const MAX_ERROR_BODY = 300;
+const REPORT_WINDOW_MS = 60_000;
+const MAX_RESPONSE_BYTES = 65_536;
+async function rejectedRecords(response, batchLength) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return 0;
+    const decoder = new TextDecoder();
+    let text = "";
+    let bytes = 0;
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            bytes += chunk.value.byteLength;
+            if (bytes > MAX_RESPONSE_BYTES)
+                throw new Error("invalid_response");
+            text += decoder.decode(chunk.value, { stream: true });
+        }
+        text += decoder.decode();
+        if (!text.trim())
+            return 0;
+        const data = JSON.parse(text);
+        if (!data || typeof data !== "object" || Array.isArray(data))
+            throw new Error("invalid_response");
+        const partial = data.partialSuccess;
+        const rejected = Number(partial?.rejectedLogRecords ?? 0);
+        if (!Number.isSafeInteger(rejected) || rejected < 0 || rejected > batchLength)
+            throw new Error("invalid_response");
+        return rejected;
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
 // OTLP severity numbers (logs data model): the base of each 4-value band.
 const SEVERITY_NUMBERS = { debug: 5, info: 9, warn: 13, error: 17 };
 // Set by log() on every record; they become the OTLP record's own fields rather
 // than attributes, so carrying them twice would just inflate every batch.
-const RECORD_FIELDS_NOT_ATTRIBUTES = new Set(["ts", "level", "msg"]);
+const RECORD_FIELDS_NOT_ATTRIBUTES = new Set(["ts", "level", "msg", "trace_id", "span_id"]);
+/**
+ * Reads `OXYGEN_LOG_OTLP_MIN_LEVEL` (debug|info|warn|error, case-insensitive).
+ *
+ * The OTLP collector is the one transport a noisy tier can drown, so it alone
+ * gets a floor; Axiom and stdout keep every level. Unset ships everything, which
+ * is the behaviour before the variable existed. An unrecognised value is named
+ * through `log()` and treated as unset: dropping more than was asked is the
+ * failure an operator cannot see, so a typo errs toward shipping.
+ */
+export function resolveOtlpLogMinLevel(env = process.env) {
+    const raw = env.OXYGEN_LOG_OTLP_MIN_LEVEL?.trim().toLowerCase();
+    if (!raw)
+        return null;
+    if (Object.hasOwn(SEVERITY_NUMBERS, raw))
+        return raw;
+    log("warn", "otlp_log_sink.min_level_invalid", {
+        min_level: raw.slice(0, 32),
+        allowed: Object.keys(SEVERITY_NUMBERS).join("|"),
+    });
+    return null;
+}
+/**
+ * The `code` of a transport error's `cause` (undici puts ECONNREFUSED,
+ * UND_ERR_CONNECT_TIMEOUT and the like there), and nothing else: the message
+ * and the error itself can carry the request URL and, with it, collector
+ * tokens. Anything that is not a short identifier-shaped code is dropped.
+ */
+function sanitizedErrorCause(error) {
+    const cause = error && typeof error === "object" ? error.cause : undefined;
+    const code = cause && typeof cause === "object" ? cause.code : undefined;
+    return typeof code === "string" && /^[A-Z][A-Z0-9_]{1,63}$/.test(code) ? code : null;
+}
 /**
  * `k=v,k=v` — the same shape as `OTEL_EXPORTER_OTLP_HEADERS`, so an operator who
  * knows the OTel variable can set ours without learning a second syntax. A pair
@@ -71,15 +143,37 @@ function timeUnixNano(ts) {
     // Decimal string, not a number: nanoseconds since the epoch exceed 2^53.
     return `${millis}000000`;
 }
-function toLogRecord(record) {
-    const level = typeof record.level === "string" && record.level in SEVERITY_NUMBERS
+/**
+ * The identity contract's tier when `OXYGEN_DEPLOY_ENV` is set, else null. An
+ * invalid value is the boot guard's to refuse; a telemetry sink created before
+ * that guard must not throw on it and take the logger down with it.
+ */
+function deployTierOrNull() {
+    if (!process.env.OXYGEN_DEPLOY_ENV)
+        return null;
+    try {
+        return resolveDeployEnv().tier;
+    }
+    catch {
+        return null;
+    }
+}
+function recordLevel(record) {
+    return typeof record.level === "string" && Object.hasOwn(SEVERITY_NUMBERS, record.level)
         ? record.level
         : "info";
+}
+function toLogRecord(record) {
+    const level = recordLevel(record);
     return {
         timeUnixNano: timeUnixNano(record.ts),
         severityNumber: SEVERITY_NUMBERS[level],
         severityText: level.toUpperCase(),
         body: { stringValue: typeof record.msg === "string" ? record.msg : String(record.msg ?? "") },
+        ...(typeof record.trace_id === "string" && /^[a-f\d]{32}$/i.test(record.trace_id)
+            && !/^0+$/.test(record.trace_id) ? { traceId: record.trace_id.toLowerCase() } : {}),
+        ...(typeof record.span_id === "string" && /^[a-f\d]{16}$/i.test(record.span_id)
+            && !/^0+$/.test(record.span_id) ? { spanId: record.span_id.toLowerCase() } : {}),
         attributes: toAttributes(record, RECORD_FIELDS_NOT_ATTRIBUTES),
     };
 }
@@ -90,54 +184,105 @@ export function createOtlpLogSink(options) {
         ? DEFAULT_FLUSH_INTERVAL_MS
         : options.flushIntervalMs;
     const doFetch = options.fetch ?? globalThis.fetch;
-    const reportWindowMs = flushIntervalMs > 0 ? flushIntervalMs : NO_TIMER_REPORT_WINDOW_MS;
+    const now = options.now ?? Date.now;
+    const minSeverity = options.minLevel ? SEVERITY_NUMBERS[options.minLevel] : null;
     // A null/undefined override is dropped rather than applied, so a caller that
     // resolves its own environment and comes back empty-handed falls back to the
     // default here instead of shipping records with no `deployment.environment`.
     const resourceOverrides = Object.fromEntries(Object.entries(options.resource ?? {}).filter(([, value]) => value !== null && value !== undefined));
     const resourceAttributes = toAttributes({
         "service.name": options.serviceName,
-        "deployment.environment": process.env.OXYGEN_DEPLOY_ENV
+        "deployment.environment": deployTierOrNull()
             ?? process.env.VERCEL_ENV
             ?? process.env.NODE_ENV
             ?? null,
+        "deployment.sha": process.env.OXYGEN_GIT_SHA ?? process.env.VERCEL_GIT_COMMIT_SHA,
         ...resourceOverrides,
     });
     const queue = [];
     let inFlight = null;
     let stopped = false;
-    let lastReportAt = 0;
-    // Never through log(): this module IS the sink log() calls, so a log() here
-    // would enqueue its own failure and re-fail on the next flush forever. stderr
-    // is the one destination that cannot re-enter, and the write is guarded
-    // because a closed/full stderr must not throw into the flush path either.
-    const report = (fields) => {
-        const now = Date.now();
-        if (now - lastReportAt < reportWindowMs)
-            return;
-        lastReportAt = now;
+    let lastReportAt = Number.NEGATIVE_INFINITY;
+    let lastOverflowReportAt = Number.NEGATIVE_INFINITY;
+    // Failed exports a throttled report skipped, and the records they dropped;
+    // both ride on the next export_failed line, as telemetry.export_failed does.
+    let suppressedFailures = 0;
+    let pendingDropped = 0;
+    // Records the overflow path dropped that no report has carried yet.
+    let droppedOverflow = 0;
+    // Re-entrancy guard, as in apps/worker/src/log-shipper.ts. log() calls this
+    // sink synchronously, so while it is set the record on offer is this sink's
+    // own report: skipped here, so a failing flush never enqueues its own error
+    // line and re-fails on it forever.
+    let emittingInternal = false;
+    const endpointForLog = telemetryEndpointForLog(options.endpoint);
+    const emitInternal = (msg, fields) => {
+        emittingInternal = true;
         try {
-            process.stderr.write(`${JSON.stringify({
-                level: "error",
-                msg: "otlp_log_sink.export_failed",
-                endpoint: options.endpoint,
-                ...fields,
-            })}\n`);
+            log("warn", msg, { endpoint: endpointForLog, ...fields });
         }
         catch {
             // A telemetry failure that cannot even be reported is still not a fault
             // of the code being observed.
         }
+        finally {
+            emittingInternal = false;
+        }
+    };
+    const report = (droppedEvents, fields) => {
+        pendingDropped += droppedEvents;
+        const at = now();
+        if (at - lastReportAt < REPORT_WINDOW_MS) {
+            suppressedFailures += 1;
+            return;
+        }
+        lastReportAt = at;
+        const overflow = droppedOverflow;
+        const dropped = pendingDropped;
+        const suppressed = suppressedFailures;
+        droppedOverflow = 0;
+        pendingDropped = 0;
+        suppressedFailures = 0;
+        emitInternal("otlp_log_sink.export_failed", {
+            ...fields,
+            dropped_events: dropped,
+            dropped_overflow: overflow,
+            suppressed_failures: suppressed,
+        });
+    };
+    // Overflow is data loss even while every export succeeds (a burst faster than
+    // the collector drains), so it is reported on its own when no failure line
+    // has carried it.
+    const reportOverflow = () => {
+        if (droppedOverflow === 0)
+            return;
+        const at = now();
+        if (at - lastOverflowReportAt < REPORT_WINDOW_MS)
+            return;
+        lastOverflowReportAt = at;
+        const overflow = droppedOverflow;
+        droppedOverflow = 0;
+        emitInternal("otlp_log_sink.queue_overflow", { dropped_events: overflow });
     };
     const sink = (record) => {
-        if (stopped)
+        if (stopped || emittingInternal)
+            return;
+        // An unknown level ships as INFO (see toLogRecord), so it filters as one.
+        if (minSeverity !== null && SEVERITY_NUMBERS[recordLevel(record)] < minSeverity)
             return;
         // Drop the OLDEST record and keep this one: under sustained backpressure the
         // newest lines are the ones describing the incident being debugged.
         while (queue.length >= maxQueue) {
             queue.shift();
+            droppedOverflow += 1;
         }
-        queue.push(record);
+        const activeSpan = trace.getActiveSpan()?.spanContext();
+        queue.push(operationalLogSnapshot(sanitizeLogFields({
+            ...record,
+            ...(activeSpan && (!record.trace_id || record.trace_id === activeSpan.traceId)
+                ? { trace_id: activeSpan.traceId, span_id: activeSpan.spanId }
+                : {}),
+        })));
     };
     const flush = async () => {
         if (inFlight)
@@ -166,25 +311,33 @@ export function createOtlpLogSink(options) {
                     body: payload,
                     signal: AbortSignal.timeout(EXPORT_TIMEOUT_MS),
                 });
-                if (response.ok)
+                if (response.ok) {
+                    try {
+                        const rejected = await rejectedRecords(response, batch.length);
+                        if (rejected)
+                            report(rejected, { status: response.status, error_code: "partial_rejection" });
+                    }
+                    catch {
+                        report(batch.length, { status: response.status, error_code: "invalid_response" });
+                    }
                     return;
-                let body = "";
-                try {
-                    body = (await response.text()).slice(0, MAX_ERROR_BODY);
-                }
-                catch {
-                    // An unreadable body is no worse than a status-only report.
                 }
+                // Receivers/proxies can echo rejected payloads or credentials. Never
+                // read arbitrary response text into operational diagnostics.
+                await response.body?.cancel().catch(() => undefined);
                 // The batch is gone deliberately: retrying into an unhealthy collector
                 // is how a telemetry path turns an ingest blip into memory pressure.
-                report({ status: response.status, dropped_events: batch.length, response_body: body });
+                report(batch.length, { status: response.status, error_code: "receiver_rejected" });
             }
             catch (error) {
-                report({
-                    dropped_events: batch.length,
-                    error_message: error instanceof Error ? error.message : String(error),
+                report(batch.length, {
+                    error_code: "transport_failed",
+                    error_cause: sanitizedErrorCause(error),
                 });
             }
+            finally {
+                reportOverflow();
+            }
         })();
         inFlight = run.finally(() => {
             inFlight = null;

package/node_modules/@oxygen/shared/dist/product-analytics-events.d.ts

@@ -42,7 +42,6 @@ export declare const PRODUCT_EVENTS: {
     readonly FIRST_PLAY_STARTED: "first_play_started";
     readonly FIRST_PLAY_STEP_COMPLETED: "first_play_step_completed";
     readonly FIRST_PLAY_COMPLETED: "first_play_completed";
-    readonly FIRST_PLAY_SKIPPED: "first_play_skipped";
     /**
      * Usage — what was ASKED for. `mcp_tool_called` used to sit here as the
      * second highest-volume event; it was REPLACED (not joined) by the reserved
@@ -70,13 +69,33 @@ export declare const PRODUCT_EVENTS: {
     readonly TABLE_INGESTION_RUN_SETTLED: "table_ingestion_run_settled";
     readonly AGENT_RUN_SETTLED: "agent_run_settled";
     readonly SEQUENCE_ENROLLMENT_SETTLED: "sequence_enrollment_settled";
+    /**
+     * A Workspace Copilot turn reached completed / failed / cancelled. The
+     * Copilot is a Control surface, not a primitive, but its turns are durable
+     * worker runs like the others and it had no outcome event at all. Counts,
+     * credits and ids only — never the user message or the assistant text.
+     */
+    readonly COPILOT_TURN_SETTLED: "copilot_turn_settled";
     /** Revenue lifecycle. */
+    /**
+     * A Stripe Checkout was opened for a first subscription. `source` says which
+     * surface opened it (a paywall, the sidebar Upgrade row, Billing) and
+     * `blocked_capability` which wall, so signup → wall → checkout →
+     * `subscription_activated` is one funnel instead of a gap between pageviews.
+     */
+    readonly CHECKOUT_STARTED: "checkout_started";
     readonly TRIAL_STARTED: "trial_started";
     readonly SUBSCRIPTION_ACTIVATED: "subscription_activated";
     readonly SUBSCRIPTION_CHURNED: "subscription_churned";
     readonly TRIAL_CANCEL_SCHEDULED: "trial_cancel_scheduled";
     readonly TRIAL_CANCEL_RESUMED: "trial_cancel_resumed";
     readonly TRIAL_ENDED_UNCONVERTED: "trial_ended_unconverted";
+    /**
+     * A paid credit top-up was granted (the Stripe Checkout fulfilment, after the
+     * ledger grant committed). `uuid` derives from the checkout session, so the
+     * webhook, the success redirect and every redelivery collapse to one event.
+     */
+    readonly CREDITS_PURCHASED: "credits_purchased";
     /**
      * Marketing site. The public hero lookup on oxygen-agent.com: an ANONYMOUS
      * visitor types their website and OXYGEN spends its own credits profiling it.
@@ -127,5 +146,5 @@ export declare const PRODUCT_EVENT_NAMES: readonly ProductEventName[];
  * emitter cannot be handed a lifecycle event that only the control plane has
  * the facts for.
  */
-export declare const WORKER_RUN_OUTCOME_EVENTS: readonly ["workflow_run_settled", "table_action_run_settled", "table_ingestion_run_settled", "agent_run_settled", "sequence_enrollment_settled"];
+export declare const WORKER_RUN_OUTCOME_EVENTS: readonly ["workflow_run_settled", "table_action_run_settled", "table_ingestion_run_settled", "agent_run_settled", "sequence_enrollment_settled", "copilot_turn_settled"];
 export type WorkerRunOutcomeEventName = (typeof WORKER_RUN_OUTCOME_EVENTS)[number];

package/node_modules/@oxygen/shared/dist/product-analytics-events.js

@@ -42,7 +42,6 @@ export const PRODUCT_EVENTS = {
     FIRST_PLAY_STARTED: "first_play_started",
     FIRST_PLAY_STEP_COMPLETED: "first_play_step_completed",
     FIRST_PLAY_COMPLETED: "first_play_completed",
-    FIRST_PLAY_SKIPPED: "first_play_skipped",
     /**
      * Usage — what was ASKED for. `mcp_tool_called` used to sit here as the
      * second highest-volume event; it was REPLACED (not joined) by the reserved
@@ -70,13 +69,33 @@ export const PRODUCT_EVENTS = {
     TABLE_INGESTION_RUN_SETTLED: "table_ingestion_run_settled",
     AGENT_RUN_SETTLED: "agent_run_settled",
     SEQUENCE_ENROLLMENT_SETTLED: "sequence_enrollment_settled",
+    /**
+     * A Workspace Copilot turn reached completed / failed / cancelled. The
+     * Copilot is a Control surface, not a primitive, but its turns are durable
+     * worker runs like the others and it had no outcome event at all. Counts,
+     * credits and ids only — never the user message or the assistant text.
+     */
+    COPILOT_TURN_SETTLED: "copilot_turn_settled",
     /** Revenue lifecycle. */
+    /**
+     * A Stripe Checkout was opened for a first subscription. `source` says which
+     * surface opened it (a paywall, the sidebar Upgrade row, Billing) and
+     * `blocked_capability` which wall, so signup → wall → checkout →
+     * `subscription_activated` is one funnel instead of a gap between pageviews.
+     */
+    CHECKOUT_STARTED: "checkout_started",
     TRIAL_STARTED: "trial_started",
     SUBSCRIPTION_ACTIVATED: "subscription_activated",
     SUBSCRIPTION_CHURNED: "subscription_churned",
     TRIAL_CANCEL_SCHEDULED: "trial_cancel_scheduled",
     TRIAL_CANCEL_RESUMED: "trial_cancel_resumed",
     TRIAL_ENDED_UNCONVERTED: "trial_ended_unconverted",
+    /**
+     * A paid credit top-up was granted (the Stripe Checkout fulfilment, after the
+     * ledger grant committed). `uuid` derives from the checkout session, so the
+     * webhook, the success redirect and every redelivery collapse to one event.
+     */
+    CREDITS_PURCHASED: "credits_purchased",
     /**
      * Marketing site. The public hero lookup on oxygen-agent.com: an ANONYMOUS
      * visitor types their website and OXYGEN spends its own credits profiling it.
@@ -132,4 +151,5 @@ export const WORKER_RUN_OUTCOME_EVENTS = Object.freeze([
     PRODUCT_EVENTS.TABLE_INGESTION_RUN_SETTLED,
     PRODUCT_EVENTS.AGENT_RUN_SETTLED,
     PRODUCT_EVENTS.SEQUENCE_ENROLLMENT_SETTLED,
+    PRODUCT_EVENTS.COPILOT_TURN_SETTLED,
 ]);

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

@@ -1,5 +1,8 @@
 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;
+// `content_preview` is raw model output (ai-column-runner's invalid_ai_output
+// details); web routes log `error_details` on a 4xx, and model text belongs in
+// Langfuse only (ADR 0014), never in operational logs.
+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|content_preview)$/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 /

package/node_modules/@oxygen/shared/dist/scraper-lane-credential.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Which key a LinkedIn scraper lane runs on (Philipp, 2026-09-25). Every lane
+ * defaults to OXYGEN's managed credits; a workspace may instead run it on its own
+ * account with the lane's vendor, which OXYGEN then never bills. The vendor is a
+ * property of the lane, so a caller picks only the mode.
+ *
+ * Browser-safe on purpose: the New table lanes render the menu from this list.
+ */
+export declare const SCRAPER_LANE_CREDENTIAL_MODES: readonly ["managed", "user_api_key"];
+export type ScraperLaneCredentialMode = (typeof SCRAPER_LANE_CREDENTIAL_MODES)[number];
+export type ScraperLane = "linkedin_posts" | "linkedin_post_engagers" | "linkedin_company_followers";
+/** The integration that stores each lane's customer key, and its display name. */
+export declare const SCRAPER_LANE_KEY_VENDOR: Readonly<Record<ScraperLane, {
+    integrationId: "up2data" | "scrapeli";
+    name: string;
+}>>;
+/** Absent means managed; anything outside the two modes is null, for the caller to refuse. */
+export declare function readScraperLaneCredentialMode(value: unknown): ScraperLaneCredentialMode | null;

package/node_modules/@oxygen/shared/dist/scraper-lane-credential.js

@@ -0,0 +1,23 @@
+/**
+ * Which key a LinkedIn scraper lane runs on (Philipp, 2026-09-25). Every lane
+ * defaults to OXYGEN's managed credits; a workspace may instead run it on its own
+ * account with the lane's vendor, which OXYGEN then never bills. The vendor is a
+ * property of the lane, so a caller picks only the mode.
+ *
+ * Browser-safe on purpose: the New table lanes render the menu from this list.
+ */
+export const SCRAPER_LANE_CREDENTIAL_MODES = ["managed", "user_api_key"];
+/** The integration that stores each lane's customer key, and its display name. */
+export const SCRAPER_LANE_KEY_VENDOR = {
+    linkedin_posts: { integrationId: "up2data", name: "Up2Data" },
+    linkedin_post_engagers: { integrationId: "up2data", name: "Up2Data" },
+    linkedin_company_followers: { integrationId: "scrapeli", name: "ScrapeLi" },
+};
+/** Absent means managed; anything outside the two modes is null, for the caller to refuse. */
+export function readScraperLaneCredentialMode(value) {
+    if (value === undefined || value === null || value === "")
+        return "managed";
+    return SCRAPER_LANE_CREDENTIAL_MODES.includes(value)
+        ? value
+        : null;
+}

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

@@ -1,6 +1,7 @@
 import { OxygenError } from "./cli-result.js";
 import { hashVariantKey, renderTemplate, spintaxSyntaxIssues, templateColumnKeys, } from "./sequence-template.js";
 import { isRecord } from "./type-guards.js";
+import { LINKEDIN_INVITE_NOTE_LIMIT } from "./linkedin-sequences.js";
 /**
  * Multichannel sequence DSL — the shared contract validated identically by CLI,
  * MCP, API, and web. A sequence is an ordered list of steps applied to each
@@ -997,7 +998,10 @@ export const SEQUENCE_CRM_IDENTITY_KINDS = [
 export const SEQUENCE_CONNECTION_BRANCH_CONDITIONS = ["connection_accepted", "already_connected", "open_profile"];
 const MAX_SEQUENCE_STEPS = 50;
 const MAX_TEMPLATE_LENGTH = 8_000;
-const MAX_NOTE_LENGTH = 300;
+// The Premium ceiling, and only an authoring hint: the limit that actually
+// binds is the SENDER's, which is lower on a Basic account and is enforced
+// against the RENDERED note at dispatch. See LINKEDIN_INVITE_NOTE_LIMIT_BASIC.
+const MAX_NOTE_LENGTH = LINKEDIN_INVITE_NOTE_LIMIT;
 const MAX_CRM_TASK_PROPERTIES = 100;
 const MAX_CRM_TASK_ASSOCIATIONS = 20;
 const MAX_CRM_RECORD_MAPPINGS = 10;

package/node_modules/@oxygen/shared/dist/signup-lead-payload.d.ts

@@ -0,0 +1,80 @@
+export type JsonRecord = Record<string, unknown>;
+export type SignupLeadWebhookSource = "clerk" | "onboarding" | "backfill" | "stripe";
+export type CustomerLifecycleEvent = "signup"
+/** Creator research completed by the onboarding bootstrap; produced by @oxygen/control-db, never by Clerk. */
+ | "signup_research" | "trial_created" | "paid" | "churned";
+export type SignupLeadWebhookInput = {
+    eventId?: string | null | undefined;
+    providerEventId?: string | null | undefined;
+    type: string;
+    source: SignupLeadWebhookSource;
+    lifecycleEvent?: CustomerLifecycleEvent | null | undefined;
+    occurredAt?: Date | string | number | null | undefined;
+    user?: {
+        clerkUserId?: string | null;
+        email?: string | null;
+        firstName?: string | null;
+        lastName?: string | null;
+        createdAt?: Date | string | number | null | undefined;
+        /** A profile URL the provider already knows for this person; the consent-recorded creator URL still wins at enqueue. */
+        linkedinUrl?: string | null;
+    };
+    organization?: {
+        clerkOrgId?: string | null;
+        name?: string | null;
+        slug?: string | null;
+        domain?: string | null;
+        createdAt?: Date | string | number | null | undefined;
+        /**
+         * Clerk user id of the organization's creator (Clerk `organization.created_by`).
+         * Downstream qualification only treats the exact creator as an acquisition
+         * lead; invited members get onboarding but no founder outreach.
+         */
+        createdBy?: string | null;
+    };
+    membership?: {
+        role?: string | null;
+    };
+    stripe?: {
+        customerId?: string | null;
+        subscriptionId?: string | null;
+        invoiceId?: string | null;
+        priceId?: string | null;
+        tier?: string | null;
+        status?: string | null;
+        trialStart?: Date | string | number | null | undefined;
+        trialEnd?: Date | string | number | null | undefined;
+        periodStart?: Date | string | number | null | undefined;
+        periodEnd?: Date | string | number | null | undefined;
+        amountPaid?: number | null;
+        currency?: string | null;
+        billingReason?: string | null;
+    };
+    metadata?: JsonRecord;
+    /** Allow-listed research evidence (`person_facts` / `company_facts`) when the producer already holds it. */
+    qualificationEvidence?: JsonRecord;
+    /** Research intent or status attached to the fact (`expected`, `scope`, `run_id`, ...). */
+    research?: JsonRecord;
+    rawEvent?: JsonRecord;
+};
+export type SignupLeadWebhookPayload = JsonRecord & {
+    id: string;
+    event_id: string;
+    event: string;
+    type: string;
+    occurred_at: string;
+    source: SignupLeadWebhookSource;
+    event_type: string;
+    provider_event_id: string;
+};
+export type WorkEmailClassification = {
+    domain: string | null;
+    isGenericMailbox: boolean;
+};
+/**
+ * Classifies an email address into a (likely) company work-email domain.
+ * Consumer/generic mailboxes return `{ domain: null, isGenericMailbox: true }`.
+ */
+export declare function classifyWorkEmail(email: string | null | undefined): WorkEmailClassification;
+export declare function isGenericMailboxDomain(domain: string | null | undefined): boolean;
+export declare function buildSignupLeadWebhookPayload(input: SignupLeadWebhookInput): SignupLeadWebhookPayload;