@oxygen-agent/cli 1.1011.98 → 1.1011.322

package/node_modules/@oxygen/shared/dist/mcp-events-enabled.d.ts

@@ -0,0 +1,2 @@
+export declare const MCP_EVENTS_ENABLED_ENV = "OXYGEN_MCP_EVENTS_ENABLED";
+export declare function mcpEventsEnabled(env?: Record<string, string | undefined>): boolean;

package/node_modules/@oxygen/shared/dist/mcp-events-enabled.js

@@ -0,0 +1,14 @@
+// The one switch for MCP Events (ADR 0030 §11, D3; ledger OXP-11.5.19). The
+// `events/*` handlers, the delivery producer and the delivery worker all read it,
+// so events are either on for every surface or off for all of them.
+//
+// Fail closed: only `1` or `true` turns events on. Unset, empty, `0`, `false`,
+// `TRUE` and anything else is off. Production keeps it unset until the
+// per-connection credit ceiling (OXP-11.5.23) exists and a human turns events on;
+// the DEV Doppler configs set it to `1`. Read from Doppler at the call site,
+// never from a remote flag service (NEVER_FLAGGABLE in ./feature-gates.ts).
+export const MCP_EVENTS_ENABLED_ENV = "OXYGEN_MCP_EVENTS_ENABLED";
+export function mcpEventsEnabled(env = process.env) {
+    const value = env[MCP_EVENTS_ENABLED_ENV]?.trim();
+    return value === "1" || value === "true";
+}

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

@@ -2,6 +2,7 @@ type AttributeContainer = {
     attributes?: Record<string, unknown>;
     name?: string;
 };
+export declare function maskEmails(value: string): string;
 /** Sink-local copy; the managed logger retains its original record. */
 export declare function operationalLogSnapshot(record: Record<string, unknown>): Record<string, unknown>;
 /** Export a sanitized copy; never mutate the span another destination reads. */

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

@@ -3,18 +3,22 @@ import { forwardExporterMethods } from "./telemetry-export-observer.js";
 // Namespaced semantic-convention fields evade the generic exact-key log policy.
 // Numeric usage remains operational data, subject to the shared secret policy.
 const PAYLOAD_KEY = /(?:^|[._-])(?:prompts?|completions?|inputs?|outputs?|payloads?|rows?|messages?|content|body|customer_data)(?:$|[._-])|^(?:request|response)$/i;
+// Error text, not a message body: ADR 0023 logs the detail withheld from a
+// customer as `error_message` (errorFields) or `<scope>_error_message`, and
+// SigNoz is the only dev log store. Sanitized like `error` (decided 2026-09-29).
+const ERROR_TEXT_KEY = /(?:^|_)error_message$/i;
 const EXCEPTION_CONTENT = /^exception\.(?:message|stacktrace)$/i;
 const QUERY_CONTENT = /^(?:db\.(?:statement|query\.text)(?:[._].*)?|(?:http|url)\.(?:query|query_string|request\.query)|process\.command(?:_args|_line)?)$/i;
 // Addresses keep their domain (the operational signal) and drop the person.
 const EMAIL_ADDRESS = /[A-Za-z0-9._%+-]+@((?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,})/g;
-function maskEmails(value) {
+export function maskEmails(value) {
     return value.replace(EMAIL_ADDRESS, "***@$1");
 }
 function operationalText(value) {
     return maskEmails(redactSecretsInString(value).replace(/(?:https?:\/\/|\/)[^\s"'<>]+/gi, stripOperationalUrl));
 }
 function operationalValue(value, key, depth = 0) {
-    if (PAYLOAD_KEY.test(key) && typeof value !== "number" && typeof value !== "boolean")
+    if (PAYLOAD_KEY.test(key) && !ERROR_TEXT_KEY.test(key) && typeof value !== "number" && typeof value !== "boolean")
         return "[omitted]";
     if (typeof value === "string")
         return /(?:^|[._-])(?:url|path|target|href)(?:$|[._-])/i.test(key)

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

@@ -46,13 +46,17 @@ export type OtlpLogSinkOptions = {
     /** 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`.
+     * Lowest level this sink ships, except exact messages listed in
+     * includeMessagesBelowMinLevel. Null or absent ships every level. Sinks
+     * composed beside this one (Axiom) and stdout are unaffected.
      */
     minLevel?: LogLevel | null | undefined;
+    /** Exact, low-volume monitor events that must reach OTLP below minLevel. */
+    includeMessagesBelowMinLevel?: readonly string[] | undefined;
     fetch?: typeof globalThis.fetch | undefined;
 };
+/** Source alerts #13, #16, #17, #19, #43, #45, #51, #71, #73, #75–77, #87, #90, #92, #95 and #97 need these INFO events. */
+export declare const OTLP_MONITOR_INFO_EVENTS: readonly ["tenant.migrations.cron.done", "outbound_send.sent", "worker_workflow_cron_overlap_skipped", "worker_workflow_cron_enqueued", "copilot.turn.finished", "worker.queue.heartbeat", "worker.queue.ledger", "worker.queue.redis", "worker.queue.unregistered_kind", "automation_usage.reconcile_completed", "provider_health.cron_completed", "provider_balances.cron_completed", "cost_snapshot.cron_completed", "worker.egress_order_reconcile_sweep", "posthog_canary.round_trip_ok", "web.log_volume"];
 export type OtlpLogSinkHandle = {
     sink: LogSink;
     flush: () => Promise<void>;

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

@@ -6,6 +6,25 @@ import { sanitizeLogFields } from "./redaction.js";
 import { trace } from "@opentelemetry/api";
 import { operationalLogSnapshot } from "./operational-telemetry.js";
 import { telemetryEndpointForLog } from "./telemetry-export-observer.js";
+/** Source alerts #13, #16, #17, #19, #43, #45, #51, #71, #73, #75–77, #87, #90, #92, #95 and #97 need these INFO events. */
+export const OTLP_MONITOR_INFO_EVENTS = [
+    "tenant.migrations.cron.done",
+    "outbound_send.sent",
+    "worker_workflow_cron_overlap_skipped",
+    "worker_workflow_cron_enqueued",
+    "copilot.turn.finished",
+    "worker.queue.heartbeat",
+    "worker.queue.ledger",
+    "worker.queue.redis",
+    "worker.queue.unregistered_kind",
+    "automation_usage.reconcile_completed",
+    "provider_health.cron_completed",
+    "provider_balances.cron_completed",
+    "cost_snapshot.cron_completed",
+    "worker.egress_order_reconcile_sweep",
+    "posthog_canary.round_trip_ok",
+    "web.log_volume",
+];
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_FLUSH_INTERVAL_MS = 2_000;
 const DEFAULT_MAX_QUEUE = 10_000;
@@ -189,6 +208,7 @@ export function createOtlpLogSink(options) {
     const doFetch = options.fetch ?? globalThis.fetch;
     const now = options.now ?? Date.now;
     const minSeverity = options.minLevel ? SEVERITY_NUMBERS[options.minLevel] : null;
+    const includedMessages = new Set(options.includeMessagesBelowMinLevel ?? []);
     // 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`.
@@ -275,7 +295,8 @@ export function createOtlpLogSink(options) {
         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)
+        if (minSeverity !== null && SEVERITY_NUMBERS[recordLevel(record)] < minSeverity
+            && (typeof record.msg !== "string" || !includedMessages.has(record.msg)))
             return;
         // Drop the OLDEST record and keep this one: under sustained backpressure the
         // newest lines are the ones describing the incident being debugged.

package/node_modules/@oxygen/shared/dist/plan-limits.d.ts

@@ -807,21 +807,17 @@ export declare function resolvePlanAgentCreditLimits(tier: LimitsTier, options?:
  */
 export declare const AGENT_RUN_APPROVED_CEILING_MAX_CREDITS = 25000;
 /** Where an org's default Agent run ceiling came from. */
-export type AgentRunDefaultCeilingSource = "plan" | "enterprise_contract";
+export type AgentRunDefaultCeilingSource = "plan";
 /** The Agent run ceilings an org's runs are held to without a further approval. */
 export type AgentRunDefaultCeilings = PlanAgentCreditLimits & {
     source: AgentRunDefaultCeilingSource;
 };
 /**
- * The default Agent run ceilings for an org: its plan rung's, unless an
- * enterprise contract names its own default (decision F.4). The contract value
- * replaces the rung's total and model calls take half of it, as on every paid
- * rung. A contract value is clamped to the platform backstop; an unusable one
- * (absent, non-numeric, not positive) is ignored.
+ * The default Agent run ceilings for an org come from its plan rung. Enterprise
+ * uses the $1,999 rung; any higher run ceiling needs explicit approval.
  */
 export declare function resolveAgentRunDefaultCeilings(input: {
     tier: LimitsTier;
-    enterpriseDefaultCredits?: number | null;
     options?: RepricingOptions;
 }): AgentRunDefaultCeilings;
 /** `details.approval_kind` on the refusal below, so every surface can render its own approval card. */

package/node_modules/@oxygen/shared/dist/plan-limits.js

@@ -368,22 +368,10 @@ export function resolvePlanAgentCreditLimits(tier, options = {}) {
  */
 export const AGENT_RUN_APPROVED_CEILING_MAX_CREDITS = 25_000;
 /**
- * The default Agent run ceilings for an org: its plan rung's, unless an
- * enterprise contract names its own default (decision F.4). The contract value
- * replaces the rung's total and model calls take half of it, as on every paid
- * rung. A contract value is clamped to the platform backstop; an unusable one
- * (absent, non-numeric, not positive) is ignored.
+ * The default Agent run ceilings for an org come from its plan rung. Enterprise
+ * uses the $1,999 rung; any higher run ceiling needs explicit approval.
  */
 export function resolveAgentRunDefaultCeilings(input) {
-    const contract = input.enterpriseDefaultCredits;
-    if (typeof contract === "number" && Number.isFinite(contract) && contract >= 1) {
-        const total = Math.min(Math.floor(contract), AGENT_RUN_APPROVED_CEILING_MAX_CREDITS);
-        return {
-            maxTotalCredits: total,
-            maxInferenceCredits: Math.max(1, Math.floor(total / 2)),
-            source: "enterprise_contract",
-        };
-    }
     return { ...resolvePlanAgentCreditLimits(input.tier, input.options), source: "plan" };
 }
 /** `details.approval_kind` on the refusal below, so every surface can render its own approval card. */

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

@@ -33,3 +33,9 @@ export type SelectOption = {
     order: number;
 };
 export declare function normalizeSelectOptions(raw: unknown): SelectOption[];
+/**
+ * The id an option carries when it declares none, derived from its value. The
+ * web option editor saves new options with an empty id, so this is also how a
+ * stored cell value maps back to its option id (MCP stage events use it).
+ */
+export declare function slugifyOption(value: string): string;

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

@@ -145,7 +145,12 @@ function readTrimmedString(value) {
     const trimmed = value.trim();
     return trimmed ? trimmed : null;
 }
-function slugifyOption(value) {
+/**
+ * The id an option carries when it declares none, derived from its value. The
+ * web option editor saves new options with an empty id, so this is also how a
+ * stored cell value maps back to its option id (MCP stage events use it).
+ */
+export function slugifyOption(value) {
     const slug = value
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "_")

package/node_modules/@oxygen/shared/dist/sending-schedule.d.ts

@@ -0,0 +1,39 @@
+import type { SequenceSendWindow } from "./sequences.js";
+/**
+ * The one sending schedule Launch shows (web editor, CLI `--schedule-*`, MCP
+ * `sending_schedule`). Email and social dispatch keep separate stored windows,
+ * `settings.email_send_window` and `settings.schedule`, so one schedule is
+ * written to both.
+ *
+ * A leaf of its own, importing only types: the Launch editor's day and time
+ * pickers are also rendered on Connections, and a value import of the whole
+ * sequences module added 13.8 KB gzip to that page (measured 2026-09-29).
+ */
+export type SendingSchedule = {
+    timezone: string;
+    days: number[];
+    start: string;
+    end: string;
+};
+/**
+ * The settings fragment that applies one schedule to every channel. The email
+ * window keeps its recipient-timezone fields; the social window takes the same
+ * zone, days and hours.
+ */
+export declare function sendingScheduleSettings(emailWindow: SequenceSendWindow | null | undefined, schedule: SendingSchedule): {
+    email_send_window: SequenceSendWindow;
+    schedule: SendingSchedule;
+};
+/**
+ * Stable comparison key for a window: zone, sorted ISO days and hours. Days are
+ * read the way dispatch reads them (sendWindowAllowsWeekday in ./sequences):
+ * day names count, and a missing, malformed or unrecognisable list means every
+ * day.
+ */
+export declare function sendingScheduleKey(window: Pick<SequenceSendWindow, "timezone" | "days" | "start" | "end">): string;
+/**
+ * Whether a mixed journey's two stored windows disagree: the social window is
+ * unset, or its zone, days or hours differ from the effective email window.
+ * Launch marks this state and the launch check warns about it.
+ */
+export declare function sendingWindowsDiverge(effectiveEmailWindow: SequenceSendWindow, socialWindow: Pick<SequenceSendWindow, "timezone" | "days" | "start" | "end"> | null | undefined): boolean;

package/node_modules/@oxygen/shared/dist/sending-schedule.js

@@ -0,0 +1,41 @@
+/**
+ * The settings fragment that applies one schedule to every channel. The email
+ * window keeps its recipient-timezone fields; the social window takes the same
+ * zone, days and hours.
+ */
+export function sendingScheduleSettings(emailWindow, schedule) {
+    return { email_send_window: { ...emailWindow, ...schedule }, schedule: { ...schedule } };
+}
+/**
+ * Stable comparison key for a window: zone, sorted ISO days and hours. Days are
+ * read the way dispatch reads them (sendWindowAllowsWeekday in ./sequences):
+ * day names count, and a missing, malformed or unrecognisable list means every
+ * day.
+ */
+export function sendingScheduleKey(window) {
+    const listed = Array.isArray(window.days) ? window.days : [];
+    const days = [...new Set(listed.map(isoWeekdayOf).filter((day) => day !== null))].sort((a, b) => a - b);
+    return JSON.stringify({
+        timezone: window.timezone,
+        days: days.length > 0 ? days : [1, 2, 3, 4, 5, 6, 7],
+        start: window.start,
+        end: window.end,
+    });
+}
+/**
+ * Whether a mixed journey's two stored windows disagree: the social window is
+ * unset, or its zone, days or hours differ from the effective email window.
+ * Launch marks this state and the launch check warns about it.
+ */
+export function sendingWindowsDiverge(effectiveEmailWindow, socialWindow) {
+    return !socialWindow || sendingScheduleKey(socialWindow) !== sendingScheduleKey(effectiveEmailWindow);
+}
+const WEEKDAY_BY_NAME = { Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6, Sun: 7 };
+function isoWeekdayOf(entry) {
+    const day = typeof entry === "number"
+        ? entry
+        : typeof entry === "string"
+            ? WEEKDAY_BY_NAME[`${entry.trim().slice(0, 1).toUpperCase()}${entry.trim().slice(1, 3).toLowerCase()}`] ?? Number(entry)
+            : Number.NaN;
+    return Number.isInteger(day) && day >= 1 && day <= 7 ? day : null;
+}

package/node_modules/@oxygen/shared/dist/sequence-lifecycle.d.ts

@@ -0,0 +1,19 @@
+/** Every lifecycle a person reads: the stored statuses plus the derived `completed`. */
+export declare const SEQUENCE_LIFECYCLES: readonly ["draft", "active", "completed", "paused", "archived"];
+export type SequenceLifecycle = (typeof SEQUENCE_LIFECYCLES)[number];
+/**
+ * The lifecycle word a person reads for a Sequence.
+ *
+ * The stored status records launch intent only (draft, active, paused,
+ * archived), and nothing moves it when the last lead finishes, so a campaign
+ * that contacted everyone kept reading "Active" forever. Whether work remains
+ * is the derived operational state; `drained` means every enrolled lead has
+ * reached an end. An active Sequence in that state reads as completed.
+ *
+ * Derived on read and never stored: operational health is one derived
+ * contract, not another lifecycle (docs/primitives/sequences.md, 2026-08-26).
+ * Enrolling new leads makes the same Sequence read as active again with no
+ * transition to undo. A paused Sequence stays paused, because someone decided
+ * that and the decision still holds.
+ */
+export declare function sequenceDisplayStatus<Status extends string>(status: Status, operationalState: string | null | undefined): Status | "completed";

package/node_modules/@oxygen/shared/dist/sequence-lifecycle.js

@@ -0,0 +1,20 @@
+/** Every lifecycle a person reads: the stored statuses plus the derived `completed`. */
+export const SEQUENCE_LIFECYCLES = ["draft", "active", "completed", "paused", "archived"];
+/**
+ * The lifecycle word a person reads for a Sequence.
+ *
+ * The stored status records launch intent only (draft, active, paused,
+ * archived), and nothing moves it when the last lead finishes, so a campaign
+ * that contacted everyone kept reading "Active" forever. Whether work remains
+ * is the derived operational state; `drained` means every enrolled lead has
+ * reached an end. An active Sequence in that state reads as completed.
+ *
+ * Derived on read and never stored: operational health is one derived
+ * contract, not another lifecycle (docs/primitives/sequences.md, 2026-08-26).
+ * Enrolling new leads makes the same Sequence read as active again with no
+ * transition to undo. A paused Sequence stays paused, because someone decided
+ * that and the decision still holds.
+ */
+export function sequenceDisplayStatus(status, operationalState) {
+    return status === "active" && operationalState === "drained" ? "completed" : status;
+}

package/node_modules/@oxygen/shared/dist/sequence-sender-variables.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reserved `{{sender_*}}` template variables. Every Sequence step can use them
+ * without a lead-table column: they resolve per action from whoever actually
+ * sends it, the person behind the sending inbox or LinkedIn/WhatsApp account.
+ * A lead column with the same key still wins, because row values merge last.
+ */
+export declare const SEQUENCE_SENDER_NAME_VARIABLES: readonly ["sender_first_name", "sender_last_name", "sender_full_name", "sender_name"];
+/** Email steps only: the sending inbox's address. */
+export declare const SEQUENCE_SENDER_EMAIL_VARIABLE = "sender_email";
+export declare const SEQUENCE_SENDER_VARIABLES: readonly string[];
+/** Editor labels, in menu order. `sender_name` stays insertable-by-hand only. */
+export declare const SEQUENCE_SENDER_VARIABLE_LABELS: ReadonlyArray<{
+    key: string;
+    label: string;
+    emailOnly?: boolean;
+}>;
+/**
+ * Who sends an action: the sender profile's own first and last name when it has
+ * them, else a display name (a profile's label, an account's or an inbox's).
+ */
+export type SequenceSenderIdentity = {
+    name?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+};
+/**
+ * The reserved variables for one sender. A profile's stored first and last name
+ * win, because its display name may be a label such as "Talia (EU)". Without
+ * them the display name is split at its first space, so "Anna von Berg" gives
+ * "Anna" and "von Berg". A missing name renders every variable empty, never the
+ * literal token. Passing `email` adds `{{sender_email}}`.
+ */
+export declare function sequenceSenderVariables(sender: SequenceSenderIdentity | string | null | undefined, email?: string | null): Record<string, string>;
+/** Whether any of these templates refers to a reserved sender variable. */
+export declare function referencesSequenceSenderVariables(templates: ReadonlyArray<unknown>): boolean;

package/node_modules/@oxygen/shared/dist/sequence-sender-variables.js

@@ -0,0 +1,63 @@
+/**
+ * Reserved `{{sender_*}}` template variables. Every Sequence step can use them
+ * without a lead-table column: they resolve per action from whoever actually
+ * sends it, the person behind the sending inbox or LinkedIn/WhatsApp account.
+ * A lead column with the same key still wins, because row values merge last.
+ */
+export const SEQUENCE_SENDER_NAME_VARIABLES = [
+    "sender_first_name",
+    "sender_last_name",
+    "sender_full_name",
+    "sender_name",
+];
+/** Email steps only: the sending inbox's address. */
+export const SEQUENCE_SENDER_EMAIL_VARIABLE = "sender_email";
+export const SEQUENCE_SENDER_VARIABLES = [
+    ...SEQUENCE_SENDER_NAME_VARIABLES,
+    SEQUENCE_SENDER_EMAIL_VARIABLE,
+];
+/** Editor labels, in menu order. `sender_name` stays insertable-by-hand only. */
+export const SEQUENCE_SENDER_VARIABLE_LABELS = [
+    { key: "sender_first_name", label: "Sender first name" },
+    { key: "sender_last_name", label: "Sender last name" },
+    { key: "sender_full_name", label: "Sender full name" },
+    { key: SEQUENCE_SENDER_EMAIL_VARIABLE, label: "Sender email", emailOnly: true },
+];
+/**
+ * The reserved variables for one sender. A profile's stored first and last name
+ * win, because its display name may be a label such as "Talia (EU)". Without
+ * them the display name is split at its first space, so "Anna von Berg" gives
+ * "Anna" and "von Berg". A missing name renders every variable empty, never the
+ * literal token. Passing `email` adds `{{sender_email}}`.
+ */
+export function sequenceSenderVariables(sender, email) {
+    const identity = typeof sender === "string" ? { name: sender } : (sender ?? {});
+    const clean = (value) => (value ?? "").trim().replace(/\s+/g, " ");
+    const firstName = clean(identity.firstName);
+    const lastName = clean(identity.lastName);
+    let first;
+    let last;
+    let full;
+    if (firstName || lastName) {
+        first = firstName;
+        last = lastName;
+        full = [firstName, lastName].filter(Boolean).join(" ");
+    }
+    else {
+        full = clean(identity.name);
+        const [head = "", ...rest] = full ? full.split(" ") : [];
+        first = head;
+        last = rest.join(" ");
+    }
+    return {
+        sender_first_name: first,
+        sender_last_name: last,
+        sender_full_name: full,
+        sender_name: full,
+        ...(email !== undefined ? { sender_email: email ?? "" } : {}),
+    };
+}
+/** Whether any of these templates refers to a reserved sender variable. */
+export function referencesSequenceSenderVariables(templates) {
+    return templates.some((text) => typeof text === "string" && /\{\{\s*sender_/.test(text));
+}

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

@@ -933,16 +933,22 @@ export type SequenceLintIssue = {
     message: string;
 };
 /**
- * A non-blocking fact about how a definition was normalized that its author must
- * be told, as opposed to an issue that rejects it. Today exactly one:
- * `email_reply_rewritten`. The retired kind is accepted and rewritten into a
- * subject-less `email_send`, and a caller that only reads the stored definition
- * back sees a different `kind` than it wrote with nothing in the response to
- * explain it — reported as a silent coercion by a customer (Plain T-163).
+ * A non-blocking fact about a saved definition that its author must be told, as
+ * opposed to an issue that rejects it:
+ *  - `email_reply_rewritten`: the retired kind is accepted and rewritten into a
+ *    subject-less `email_send`, and a caller that only reads the stored
+ *    definition back sees a different `kind` than it wrote with nothing in the
+ *    response to explain it — reported as a silent coercion by a customer
+ *    (Plain T-163).
+ *  - `sequence_linkedin_owner_conflict`: a draft saves LinkedIn relationship
+ *    steps that name different people, which only the launch refuses (same
+ *    code as its launch blocker and the preview's `blocked` marker). A blind MCP run
+ *    pinned the founder on the connection request alone and learned why the
+ *    draft could not launch only from the start preview (2026-09-29).
  */
 export type SequenceDefinitionNotice = {
     path: string;
-    code: "email_reply_rewritten";
+    code: "email_reply_rewritten" | "sequence_linkedin_owner_conflict";
     message: string;
 };
 export type ValidateSequenceOptions = {

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

@@ -1110,6 +1110,25 @@ export function sequenceLinkedInOwnerConflicts(steps) {
         message: `step '${step.id}': every LinkedIn connection, message and InMail step must come from the same person (or all from the lead's own). LinkedIn lets one of your accounts hold a conversation with a lead.`,
     }));
 }
+/**
+ * The draft-save counterpart of the launch's `sequence_linkedin_owner_conflict`:
+ * one notice naming what each relationship step sends from, and both ways out.
+ */
+function sequenceLinkedInOwnerNotice(steps) {
+    const conflicts = sequenceLinkedInOwnerConflicts(steps);
+    const first = conflicts[0];
+    if (!first)
+        return null;
+    const named = conflicts.map(({ index, stepId }) => {
+        const person = steps[index] ? stepSenderProfileId(steps[index]) : undefined;
+        return person ? `'${stepId}' names ${person}` : `'${stepId}' names no one`;
+    });
+    return {
+        path: `steps[${first.index}].sender_profile_id`,
+        code: "sequence_linkedin_owner_conflict",
+        message: `Saved as a draft, but it cannot launch yet: LinkedIn connection, message, InMail and withdraw steps must all name the same sender_profile_id, or none (${named.join(", ")}). LinkedIn lets one of your accounts hold a conversation with a lead. To have one person send all of them, name that person on each; to keep every lead's own person, remove it from all.`,
+    };
+}
 export function sequenceStepsMissingCopy(steps) {
     const missing = [];
     const check = (step, field, value) => {
@@ -1259,6 +1278,13 @@ export function validateSequenceDefinition(input, options = {}) {
             issues.push({ path: `steps[${conflict.index}].sender_profile_id`, message: conflict.message });
         }
     }
+    else {
+        // A draft may be half-built, so a split LinkedIn owner still saves; tell the
+        // author now instead of leaving it for the launch preview to reveal.
+        const ownerNotice = sequenceLinkedInOwnerNotice(normalized);
+        if (ownerNotice)
+            options.notices?.push(ownerNotice);
+    }
     if (issues.length > 0) {
         throw new OxygenError("invalid_sequence", `Sequence definition is invalid: ${issues.map((i) => `${i.path}: ${i.message}`).join("; ")}`, { details: { issues }, exitCode: 1 });
     }

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

@@ -16,6 +16,8 @@ export type SignupLeadWebhookInput = {
         firstName?: string | null;
         lastName?: string | null;
         phone?: string | null;
+        /** Whether the provider verified `phone`; sign-up collects numbers without verifying them. */
+        phoneVerified?: boolean | 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;

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

@@ -34,6 +34,9 @@ export function buildSignupLeadWebhookPayload(input) {
     const firstName = normalizeString(input.user?.firstName);
     const lastName = normalizeString(input.user?.lastName);
     const phone = normalizeString(input.user?.phone);
+    const phoneVerified = phone && typeof input.user?.phoneVerified === "boolean"
+        ? input.user.phoneVerified
+        : null;
     const fullName = normalizeString([firstName, lastName].filter(Boolean).join(" "));
     const clerkOrgId = normalizeString(input.organization?.clerkOrgId);
     const companyName = normalizeString(input.organization?.name);
@@ -53,6 +56,7 @@ export function buildSignupLeadWebhookPayload(input) {
         first_name: firstName,
         last_name: lastName,
         phone,
+        phone_verified: phoneVerified,
         full_name: fullName,
         created_at: normalizeDate(input.user?.createdAt),
         linkedin_url: normalizeString(input.user?.linkedinUrl) ?? undefined,
@@ -121,6 +125,7 @@ export function buildSignupLeadWebhookPayload(input) {
         first_name: firstName,
         last_name: lastName,
         phone,
+        phone_verified: phoneVerified,
         full_name: fullName,
         company_name: companyName,
         company_domain: companyDomain,

package/node_modules/@oxygen/shared/dist/social-post-metrics-series.js

@@ -1,3 +1,4 @@
+import { zoneOffsetMs } from "./zoned-time.js";
 export const EARNED_SERIES_MAX_PRORATE_MS = 3 * 24 * 60 * 60 * 1000;
 function pointsFor(timeline, metric) {
     const points = [];
@@ -179,21 +180,6 @@ export function zonedDayStarts(fromDate, toDate, timeZone) {
     }
     return { days, end: startOfZonedDay(cursor.toISOString().slice(0, 10), timeZone) };
 }
-function zoneOffsetMs(instant, timeZone) {
-    const parts = new Intl.DateTimeFormat("en-US", {
-        timeZone,
-        hourCycle: "h23",
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-        second: "2-digit",
-    }).formatToParts(instant);
-    const read = (type) => Number(parts.find((part) => part.type === type)?.value ?? 0);
-    const asUtc = Date.UTC(read("year"), read("month") - 1, read("day"), read("hour"), read("minute"), read("second"));
-    return asUtc - Math.floor(instant.getTime() / 1000) * 1000;
-}
 function startOfZonedDay(date, timeZone) {
     const utcMidnight = new Date(`${date}T00:00:00.000Z`).getTime();
     const firstGuess = utcMidnight - zoneOffsetMs(new Date(utcMidnight), timeZone);

package/node_modules/@oxygen/shared/dist/standard-webhooks.d.ts

@@ -0,0 +1,51 @@
+export declare const STANDARD_WEBHOOK_SECRET_PREFIX = "whsec_";
+/** MCP Events accepts only `whsec_` secrets whose base64 value decodes to 24–64 bytes. */
+export declare const STANDARD_WEBHOOK_SECRET_MIN_BYTES = 24;
+export declare const STANDARD_WEBHOOK_SECRET_MAX_BYTES = 64;
+/** Default `webhook-timestamp` window, in either direction, as in the reference libraries. */
+export declare const STANDARD_WEBHOOK_TOLERANCE_SECONDS: number;
+export type StandardWebhookErrorReason = "secret_missing" | "secret_prefix" | "secret_encoding" | "secret_length" | "invalid_id" | "invalid_timestamp";
+/** A secret or signing input that cannot produce a valid signature. Never carries the secret. */
+export declare class StandardWebhookError extends Error {
+    readonly reason: StandardWebhookErrorReason;
+    constructor(reason: StandardWebhookErrorReason, message: string);
+}
+/** One `whsec_` secret, or several during a rotation window (every key signs). */
+export type StandardWebhookSecrets = string | readonly string[];
+/** A `Date`, or whole Unix seconds. */
+export type StandardWebhookTime = Date | number;
+export type StandardWebhookSignInput = {
+    secret: StandardWebhookSecrets;
+    id: string;
+    timestamp: StandardWebhookTime;
+    /** The exact request body. Send these same characters; re-serialising breaks the signature. */
+    body: string;
+};
+export type StandardWebhookHeaders = {
+    "webhook-id": string;
+    "webhook-timestamp": string;
+    "webhook-signature": string;
+};
+/** Decode a `whsec_` secret to its HMAC key, enforcing the 24–64 byte range. */
+export declare function parseStandardWebhookSecret(secret: string): Buffer;
+/** The `webhook-signature` value: `v1,<base64>`, space-separated when several secrets sign. */
+export declare function signStandardWebhook(input: StandardWebhookSignInput): string;
+/** The three Standard Webhooks headers for one delivery attempt. */
+export declare function standardWebhookHeaders(input: StandardWebhookSignInput): StandardWebhookHeaders;
+/**
+ * True when any `v1` entry of `signature` matches any of the secrets and the
+ * timestamp is within `toleranceSeconds` of `now`. A malformed id, timestamp or
+ * signature is `false`; an invalid secret, `now` or `toleranceSeconds` throws,
+ * because that is a misconfiguration rather than a bad request.
+ */
+export declare function verifyStandardWebhook(input: {
+    secret: StandardWebhookSecrets;
+    id: string;
+    /** The `webhook-timestamp` header as received, or a parsed time. */
+    timestamp: StandardWebhookTime | string;
+    body: string;
+    /** The `webhook-signature` header as received. */
+    signature: string;
+    toleranceSeconds?: number;
+    now?: StandardWebhookTime;
+}): boolean;