@oxygen-agent/cli 1.1014.1343 → 1.1014.1451

package/node_modules/@oxygen/shared/dist/onboarding-plays.d.ts

@@ -0,0 +1,68 @@
+export declare const ONBOARDING_PROPOSE_PLAYS_TOOL_NAME = "propose_plays";
+export declare const ONBOARDING_PLAY_LIMITS: {
+    readonly minPlays: 2;
+    readonly maxPlays: 4;
+    readonly titleChars: 80;
+    readonly lineChars: 240;
+    readonly slugChars: 120;
+};
+export type OnboardingPlay = {
+    id: string;
+    title: string;
+    /** Who it targets: segment and buyer. */
+    audience: string;
+    /** The signal or trigger it acts on. */
+    trigger: string | null;
+    /** The angle: what the message offers them. */
+    angle: string;
+    /** Why it fits this company, from the research. */
+    why: string | null;
+    /** What running it does first. */
+    firstStep: string;
+    /** The play's Knowledge page, when one was written. */
+    page: string | null;
+};
+export type OnboardingPlayProposal = {
+    id: string;
+    plays: OnboardingPlay[];
+};
+/** The proposal a chat is waiting on, as every surface reads it. */
+export type PendingOnboardingPlayProposal = OnboardingPlayProposal & {
+    turnId: string;
+};
+/** The tool's input schema, as the model reads it. */
+export declare const ONBOARDING_PROPOSE_PLAYS_INPUT_SCHEMA: Record<string, unknown>;
+/** Validate the plays the model proposed, minting ids. */
+export declare function normalizeOnboardingPlayProposal(args: Record<string, unknown>, mintId: () => string): {
+    ok: true;
+    proposal: OnboardingPlayProposal;
+} | {
+    ok: false;
+    message: string;
+};
+/** The proposal as the turn's reply: what the CLI and MCP print, and what the next turn reads back. */
+export declare function renderOnboardingPlayProposalText(proposal: OnboardingPlayProposal): string;
+/** Read a stored proposal back, refusing anything malformed. */
+export declare function readOnboardingPlayProposal(value: unknown): OnboardingPlayProposal | null;
+/** The message a chosen play sends, as the person's own. */
+export declare function onboardingPlayMessage(play: Pick<OnboardingPlay, "title" | "firstStep" | "page">): string;
+type ProjectionTurn = {
+    id: string;
+    status: string;
+    turnIndex: number;
+};
+type ProjectionEvent = {
+    turnId: string | null;
+    kind: string;
+    payload: Record<string, unknown>;
+};
+/**
+ * The plays the chat is waiting on, or null. Like a question, only the newest
+ * turn can be waiting, and only when it completed by proposing: choosing one
+ * sends a new message, which is the end of the wait.
+ */
+export declare function projectPendingOnboardingPlayProposal(input: {
+    turns: readonly ProjectionTurn[];
+    events: readonly ProjectionEvent[];
+}): PendingOnboardingPlayProposal | null;
+export {};

package/node_modules/@oxygen/shared/dist/onboarding-plays.js

@@ -0,0 +1,114 @@
+// Agent-led onboarding (Philipp, 2026-10-19): the onboarding turn ends with a
+// few proposed outbound plays as cards. Choosing one has the Oxygent run it in
+// the chat, as an ordinary message the person sent; typing steers instead.
+//
+// One owner for the contract, because four readers depend on it: the tool that
+// validates the model's proposal, the session read that projects the pending
+// one, the card that shows it and the route that runs the chosen play.
+export const ONBOARDING_PROPOSE_PLAYS_TOOL_NAME = "propose_plays";
+export const ONBOARDING_PLAY_LIMITS = {
+    minPlays: 2,
+    maxPlays: 4,
+    titleChars: 80,
+    lineChars: 240,
+    slugChars: 120,
+};
+const line = (description) => ({ type: "string", minLength: 1, maxLength: ONBOARDING_PLAY_LIMITS.lineChars, description });
+/** The tool's input schema, as the model reads it. */
+export const ONBOARDING_PROPOSE_PLAYS_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        plays: {
+            type: "array",
+            minItems: ONBOARDING_PLAY_LIMITS.minPlays,
+            maxItems: ONBOARDING_PLAY_LIMITS.maxPlays,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    title: { type: "string", minLength: 1, maxLength: ONBOARDING_PLAY_LIMITS.titleChars, description: "Short name, e.g. \"New VP Sales at Series A SaaS\"." },
+                    audience: line("Who: the segment and the buyer persona."),
+                    trigger: line("The signal or event that makes now the moment, if any."),
+                    angle: line("What the outreach offers them, in one line."),
+                    why: line("Why this fits this company, from the research."),
+                    first_step: line("What running it does first, e.g. \"Find 50 matching accounts and their VP Sales\"."),
+                    page: { type: "string", maxLength: ONBOARDING_PLAY_LIMITS.slugChars, description: "The play's Knowledge page slug, if you wrote one." },
+                },
+                required: ["title", "audience", "angle", "first_step"],
+            },
+        },
+    },
+    required: ["plays"],
+};
+const clean = (value, max) => typeof value === "string" ? value.replace(/\s+/g, " ").trim().slice(0, max) : "";
+/** Validate the plays the model proposed, minting ids. */
+export function normalizeOnboardingPlayProposal(args, mintId) {
+    const raw = Array.isArray(args.plays) ? args.plays : [];
+    const plays = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const record = entry;
+        const title = clean(record.title, ONBOARDING_PLAY_LIMITS.titleChars);
+        const audience = clean(record.audience, ONBOARDING_PLAY_LIMITS.lineChars);
+        const angle = clean(record.angle, ONBOARDING_PLAY_LIMITS.lineChars);
+        const firstStep = clean(record.first_step ?? record.firstStep, ONBOARDING_PLAY_LIMITS.lineChars);
+        if (!title || !audience || !angle || !firstStep)
+            continue;
+        const trigger = clean(record.trigger, ONBOARDING_PLAY_LIMITS.lineChars);
+        const why = clean(record.why, ONBOARDING_PLAY_LIMITS.lineChars);
+        const page = clean(record.page, ONBOARDING_PLAY_LIMITS.slugChars);
+        plays.push({ id: typeof record.id === "string" && record.id ? record.id : mintId(), title, audience, trigger: trigger || null,
+            angle, why: why || null, firstStep, page: /^[a-z0-9][a-z0-9-]*$/.test(page) ? page : null });
+    }
+    if (plays.length < ONBOARDING_PLAY_LIMITS.minPlays || plays.length > ONBOARDING_PLAY_LIMITS.maxPlays) {
+        return { ok: false, message: `Propose ${ONBOARDING_PLAY_LIMITS.minPlays} to ${ONBOARDING_PLAY_LIMITS.maxPlays} plays, each with a title, audience, angle and first step.` };
+    }
+    return { ok: true, proposal: { id: typeof args.id === "string" && args.id ? args.id : mintId(), plays } };
+}
+/** The proposal as the turn's reply: what the CLI and MCP print, and what the next turn reads back. */
+export function renderOnboardingPlayProposalText(proposal) {
+    return [
+        "Plays I'd run first:",
+        ...proposal.plays.map((play, index) => `${index + 1}. **${play.title}**: ${play.audience}. ${play.angle}`),
+        "Pick one to start it, or tell me what to change.",
+    ].join("\n");
+}
+/** Read a stored proposal back, refusing anything malformed. */
+export function readOnboardingPlayProposal(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (typeof record.id !== "string" || !record.id)
+        return null;
+    const normalized = normalizeOnboardingPlayProposal(record, () => "");
+    return normalized.ok && normalized.proposal.plays.every((play) => play.id) ? normalized.proposal : null;
+}
+/** The message a chosen play sends, as the person's own. */
+export function onboardingPlayMessage(play) {
+    return `Run the play "${play.title}". Start with: ${play.firstStep}${play.page ? ` (see [[${play.page}]])` : ""}`;
+}
+/**
+ * The plays the chat is waiting on, or null. Like a question, only the newest
+ * turn can be waiting, and only when it completed by proposing: choosing one
+ * sends a new message, which is the end of the wait.
+ */
+export function projectPendingOnboardingPlayProposal(input) {
+    const newest = input.turns.reduce((latest, turn) => (latest === null || turn.turnIndex > latest.turnIndex ? turn : latest), null);
+    if (!newest || newest.status !== "completed")
+        return null;
+    for (let index = input.events.length - 1; index >= 0; index -= 1) {
+        const event = input.events[index];
+        if (!event || event.turnId !== newest.id || event.kind !== "tool_call_finished")
+            continue;
+        if (event.payload.tool !== ONBOARDING_PROPOSE_PLAYS_TOOL_NAME)
+            continue;
+        const result = event.payload.result;
+        if (!result || typeof result !== "object" || result.ok === false)
+            continue;
+        const proposal = readOnboardingPlayProposal(result.proposal);
+        return proposal ? { ...proposal, turnId: newest.id } : null;
+    }
+    return null;
+}

package/node_modules/@oxygen/shared/dist/onboarding-research.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Agent-led onboarding's research (Philipp, 2026-10-19; OXYGEN_PRODUCT.md
+ * "Agent-led onboarding"): the first "Start onboarding" turn of a guided
+ * activation is OXYGEN-funded, and its research sub-agents may search the web,
+ * read the company's site and LinkedIn, find its people and write draft
+ * Knowledge pages in parallel, without an approval card per call. These bounds
+ * are what replaces the card. Shared by the worker (the sub-agents' grant), the
+ * tool route (who pays) and the credit rail (the funding policy).
+ */
+export declare const ONBOARDING_RESEARCH_PURPOSE = "onboarding_research";
+/** The research sub-agent the onboarding turn delegates to. */
+export declare const ONBOARDING_RESEARCH_SUBAGENT = "onboarding_researcher";
+/** Provider credits OXYGEN pays for one workspace's onboarding research, over its lifetime. */
+export declare const ONBOARDING_RESEARCH_MAX_CREDITS = 300;
+/** Ceiling on any one research call; a call that names a higher one is lowered to it. */
+export declare const ONBOARDING_RESEARCH_MAX_CREDITS_PER_CALL = 15;
+/** The onboarding turn's own and its sub-agents' inference, credited back once the turn settles. */
+export declare const ONBOARDING_RESEARCH_INFERENCE_MAX_CREDITS = 150;
+/**
+ * Eight areas at once (offer, ICP, plays, signals, competitors, company
+ * LinkedIn, people, the signing-up person), with room for one follow-up pass.
+ * Each researcher wraps up after 90 seconds: on the first live run the slowest
+ * of eight took 370 seconds and everyone waited on it (2026-10-19).
+ */
+export declare const ONBOARDING_RESEARCH_SUBAGENT_LIMITS: {
+    readonly maxRuns: 12;
+    readonly maxParallelTasks: 8;
+    readonly maxInferencesPerRun: 6;
+    readonly maxCapabilityCallsPerRun: 20;
+    readonly concludeAfterMs: 90000;
+};
+/**
+ * Read-only provider tools the research may call through `oxygen_tools_run_live`.
+ * Nothing here writes outside OXYGEN; the costly ones (competitor search at 61
+ * credits, large exa result sets) stay out or are capped per call.
+ */
+export declare const ONBOARDING_RESEARCH_TOOL_IDS: readonly ["serper.search", "exa.search", "exa.contents", "exa.find_similar", "firecrawl.map", "firecrawl.scrape", "web.page_fetch", "scraper.linkedin_company", "scraper.linkedin_profile", "scraper.linkedin_profile_search", "scraper.linkedin_job_search", "blitzapi.employee_search", "blitzapi.person_profile_enrich", "blitzapi.company_profile_enrich", "predictleads.company_news_events", "predictleads.company_job_openings", "predictleads.company_similar_companies"];
+export declare function onboardingResearchToolAllowed(toolId: unknown): boolean;
+/** The hub pages the onboarding Oxygent itself writes; research links to them and never creates them. */
+export declare const ONBOARDING_RESEARCH_HUB_SLUGS: readonly ["company", "offers", "icp", "plays", "signals", "competitors", "team"];
+/** Knowledge page types a research sub-agent may not write: canonical voice and positioning stay proposal-gated. */
+export declare const ONBOARDING_RESEARCH_DENIED_PAGE_TYPES: readonly ["voice", "brand", "positioning", "message_playbook", "playbook"];

package/node_modules/@oxygen/shared/dist/onboarding-research.js

@@ -0,0 +1,62 @@
+/**
+ * Agent-led onboarding's research (Philipp, 2026-10-19; OXYGEN_PRODUCT.md
+ * "Agent-led onboarding"): the first "Start onboarding" turn of a guided
+ * activation is OXYGEN-funded, and its research sub-agents may search the web,
+ * read the company's site and LinkedIn, find its people and write draft
+ * Knowledge pages in parallel, without an approval card per call. These bounds
+ * are what replaces the card. Shared by the worker (the sub-agents' grant), the
+ * tool route (who pays) and the credit rail (the funding policy).
+ */
+export const ONBOARDING_RESEARCH_PURPOSE = "onboarding_research";
+/** The research sub-agent the onboarding turn delegates to. */
+export const ONBOARDING_RESEARCH_SUBAGENT = "onboarding_researcher";
+/** Provider credits OXYGEN pays for one workspace's onboarding research, over its lifetime. */
+export const ONBOARDING_RESEARCH_MAX_CREDITS = 300;
+/** Ceiling on any one research call; a call that names a higher one is lowered to it. */
+export const ONBOARDING_RESEARCH_MAX_CREDITS_PER_CALL = 15;
+/** The onboarding turn's own and its sub-agents' inference, credited back once the turn settles. */
+export const ONBOARDING_RESEARCH_INFERENCE_MAX_CREDITS = 150;
+/**
+ * Eight areas at once (offer, ICP, plays, signals, competitors, company
+ * LinkedIn, people, the signing-up person), with room for one follow-up pass.
+ * Each researcher wraps up after 90 seconds: on the first live run the slowest
+ * of eight took 370 seconds and everyone waited on it (2026-10-19).
+ */
+export const ONBOARDING_RESEARCH_SUBAGENT_LIMITS = {
+    maxRuns: 12,
+    maxParallelTasks: 8,
+    maxInferencesPerRun: 6,
+    maxCapabilityCallsPerRun: 20,
+    concludeAfterMs: 90_000,
+};
+/**
+ * Read-only provider tools the research may call through `oxygen_tools_run_live`.
+ * Nothing here writes outside OXYGEN; the costly ones (competitor search at 61
+ * credits, large exa result sets) stay out or are capped per call.
+ */
+export const ONBOARDING_RESEARCH_TOOL_IDS = [
+    "serper.search",
+    "exa.search",
+    "exa.contents",
+    "exa.find_similar",
+    "firecrawl.map",
+    "firecrawl.scrape",
+    "web.page_fetch",
+    "scraper.linkedin_company",
+    "scraper.linkedin_profile",
+    "scraper.linkedin_profile_search",
+    "scraper.linkedin_job_search",
+    "blitzapi.employee_search",
+    "blitzapi.person_profile_enrich",
+    "blitzapi.company_profile_enrich",
+    "predictleads.company_news_events",
+    "predictleads.company_job_openings",
+    "predictleads.company_similar_companies",
+];
+export function onboardingResearchToolAllowed(toolId) {
+    return typeof toolId === "string" && ONBOARDING_RESEARCH_TOOL_IDS.includes(toolId);
+}
+/** The hub pages the onboarding Oxygent itself writes; research links to them and never creates them. */
+export const ONBOARDING_RESEARCH_HUB_SLUGS = ["company", "offers", "icp", "plays", "signals", "competitors", "team"];
+/** Knowledge page types a research sub-agent may not write: canonical voice and positioning stay proposal-gated. */
+export const ONBOARDING_RESEARCH_DENIED_PAGE_TYPES = ["voice", "brand", "positioning", "message_playbook", "playbook"];

package/node_modules/@oxygen/shared/dist/placement-copy.d.ts

@@ -0,0 +1,8 @@
+/** Browser-safe copy policy shared by placement forms and native request owners. */
+export declare const PLACEMENT_COPY_GUIDANCE = "Use the outreach email you would send to a prospect. Import a Sequence step or write realistic copy; do not use delivery-check text or no-reply notices.";
+export declare const PLACEMENT_SAMPLE_COPY: {
+    subject: string;
+    body_text: string;
+};
+/** Reject obvious diagnostic placeholders, without scoring or rewriting outreach. */
+export declare function placementCopyIssue(subject: string, bodyText: string, bodyHtml?: string): string | null;

package/node_modules/@oxygen/shared/dist/placement-copy.js

@@ -0,0 +1,16 @@
+/** Browser-safe copy policy shared by placement forms and native request owners. */
+export const PLACEMENT_COPY_GUIDANCE = "Use the outreach email you would send to a prospect. Import a Sequence step or write realistic copy; do not use delivery-check text or no-reply notices.";
+export const PLACEMENT_SAMPLE_COPY = {
+    subject: "A question about your outbound workflow",
+    body_text: "Hi,\n\nHow does your team move from a list of target accounts to personalized outreach today?\n\nWe help teams keep research, enrichment and follow-ups in one workspace so reps spend less time moving data between tools.\n\nWould it be useful to compare that with your current workflow?",
+};
+/** Reject obvious diagnostic placeholders, without scoring or rewriting outreach. */
+export function placementCopyIssue(subject, bodyText, bodyHtml) {
+    if (!subject.trim() || !bodyText.trim())
+        return PLACEMENT_COPY_GUIDANCE;
+    const diagnosticSubject = /^(?:(?:oxygen|emailguard|sendkit|dev|workspace|internal|plain|html)\s+)*(?:(?:inbox[ -]placement|inbox|deliverability|delivery|placement|spam|primary)(?:\s+(?:test|check|probe))|test\s+(?:email|message))(?:\s|[:—–-]|$)/i;
+    const diagnosticBody = /\b(?:this\s+(?:(?:email|message)\s+)?is\s+(?:an?\s+|the\s+)?(?:(?:oxygen|dev|workspace)\s+)*(?:inbox[ -]placement|inbox|deliverability|delivery|placement)\s+(?:test|check|probe)|no\s+(?:reply|response)\s+(?:is\s+)?(?:needed|required)|do\s+not\s+reply)\b/i;
+    const htmlText = bodyHtml?.replace(/<[^<>]*>/g, " ").replace(/&nbsp;|&#160;/gi, " ") ?? "";
+    return diagnosticSubject.test(subject.trim()) || diagnosticBody.test(bodyText) || diagnosticBody.test(htmlText)
+        ? PLACEMENT_COPY_GUIDANCE : null;
+}

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

@@ -25,6 +25,14 @@ export declare const PRODUCT_EVENTS: {
     readonly ONBOARDING_RESET: "onboarding_reset";
     readonly ACTIVATION_PATH_SELECTED: "activation_path_selected";
     readonly AGENT_CONNECTED: "agent_connected";
+    /**
+     * Browser-side, on onboarding's Install OXYGEN step (`/setup/agent`): what a
+     * founder did there before connecting or leaving. `action` is agent_selected,
+     * endpoint_copied, prompt_copied, connected, open_agent, open_oxygen,
+     * copilot_instead or skipped; `agent` is claude, chatgpt or cli;
+     * `seconds_on_step` is a number. A handful per signup, never per poll.
+     */
+    readonly AGENT_SETUP_ACTION: "agent_setup_action";
     readonly FIRST_RECORD_CREATED: "first_record_created";
     /**
      * The prescribed first play (inbound-led outbound), walked on ANY surface.

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

@@ -25,6 +25,14 @@ export const PRODUCT_EVENTS = {
     ONBOARDING_RESET: "onboarding_reset",
     ACTIVATION_PATH_SELECTED: "activation_path_selected",
     AGENT_CONNECTED: "agent_connected",
+    /**
+     * Browser-side, on onboarding's Install OXYGEN step (`/setup/agent`): what a
+     * founder did there before connecting or leaving. `action` is agent_selected,
+     * endpoint_copied, prompt_copied, connected, open_agent, open_oxygen,
+     * copilot_instead or skipped; `agent` is claude, chatgpt or cli;
+     * `seconds_on_step` is a number. A handful per signup, never per poll.
+     */
+    AGENT_SETUP_ACTION: "agent_setup_action",
     FIRST_RECORD_CREATED: "first_record_created",
     /**
      * The prescribed first play (inbound-led outbound), walked on ANY surface.

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

@@ -701,13 +701,40 @@ export type SequenceStopStep = {
  *   emailsUnsubscribed   → { signal: "email_unsubscribed" }
  *   aircallDone          → out of scope (no Aircall integration)
  * Negate any leaf with present:false (e.g. "no email on file" = { has_column: "email", present: false }).
+ *
+ * A CONTACT leaf `{ has_contact: "email" | "linkedin" | "phone", present? }` asks
+ * whether the step that channel needs could reach the lead, resolved exactly as
+ * dispatch resolves it: email and phone through the sequence's mapped column with
+ * the built-in fallbacks, LinkedIn through the profile captured at enrollment. It
+ * is what "If has email / LinkedIn / phone" in the builder writes, so one campaign
+ * can route every lead instead of splitting the audience by data.
+ */
+export declare const SEQUENCE_CONTACT_CHANNELS: readonly ["email", "linkedin", "phone"];
+export type SequenceContactChannel = (typeof SEQUENCE_CONTACT_CHANNELS)[number];
+/** What a lead can be reached by, as dispatch resolves it; a contact leaf reads this. */
+export type SequenceLeadContacts = Record<SequenceContactChannel, boolean>;
+/**
+ * Resolve a lead's reachable contacts the way dispatch does: the mapped email or
+ * phone column first, then the built-in keys, and LinkedIn from the profile the
+ * enrollment captured (a row value alone never makes a LinkedIn step sendable).
  */
+export declare function sequenceLeadContacts(input: {
+    rowValues: Record<string, unknown> | null | undefined;
+    settings?: {
+        email_column_key?: string | null;
+        phone_column_key?: string | null;
+    } | null;
+    linkedin: boolean;
+}): SequenceLeadContacts;
 export type SequenceSignalCondition = {
     signal: SequenceSignal;
     present?: boolean;
 } | {
     has_column: string;
     present?: boolean;
+} | {
+    has_contact: SequenceContactChannel;
+    present?: boolean;
 } | {
     all: SequenceSignalCondition[];
 } | {
@@ -959,9 +986,10 @@ export declare function sequenceTemplateVariables(definition: SequenceDefinition
  * `rowValues` is optional and backward-compatible: when omitted (undefined), a data
  * leaf ({ has_column }) evaluates as ABSENT — present:false matches, present:true
  * does not — so an existing signal-only caller is unaffected. Signal leaves ignore
- * rowValues entirely.
+ * rowValues entirely. A contact leaf ({ has_contact }) reads `contacts`; without
+ * it, the contact counts as absent.
  */
-export declare function evaluateSequenceCondition(condition: SequenceSignalCondition, firedSignals: Iterable<string>, rowValues?: Record<string, unknown> | null): boolean;
+export declare function evaluateSequenceCondition(condition: SequenceSignalCondition, firedSignals: Iterable<string>, rowValues?: Record<string, unknown> | null, contacts?: SequenceLeadContacts): boolean;
 /** Variant label for an index: 0 → "a" (the base step), 1 → "b", … */
 export declare function sequenceVariantLabel(index: number): string;
 type StepVariantContent = Record<string, string>;

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

@@ -424,6 +424,54 @@ export const SEQUENCE_CRM_IDENTITY_KINDS = [
  *   route connected → then_id, not → else_id (no waiting).
  */
 export const SEQUENCE_CONNECTION_BRANCH_CONDITIONS = ["connection_accepted", "already_connected", "open_profile"];
+/**
+ * A boolean expression a signal-branch routes on. Two leaf kinds, plus the
+ * all/any/not combinators:
+ * - a SIGNAL leaf `{ signal, present? }` tests whether an accumulated enrollment
+ *   signal is present (default) or absent (present:false).
+ * - a DATA leaf `{ has_column, present? }` tests whether the lead's source row
+ *   carries a non-empty value in the named row_values column — present (default)
+ *   or absent (present:false). This is the LinkedIn/Lemlist "does the lead have an
+ *   email / phone / … ?" branch: route by what data you HAVE about the lead,
+ *   evaluated synchronously against the enrollment's row_values (no signal, no
+ *   wait). A value counts as present when it is a non-empty trimmed string, or any
+ *   number / boolean; null / undefined / "" / whitespace count as absent.
+ *
+ * Lemlist condition-key → Oxygen mapping (13 keys), so a Lemlist journey ports
+ * across without a lossy translation table:
+ *   hasEmailAddress      → { has_column: "email" }   (or any SEQUENCE_EMAIL_COLUMN_KEYS key)
+ *   hasLinkedinUrl       → { has_column: "<linkedin url column>" }
+ *   hasPhoneNumber       → { has_column: "phone" }    (or any SEQUENCE_PHONE_COLUMN_KEYS key)
+ *   linkedinInviteAccepted → a CONNECTION branch (condition: "connection_accepted")
+ *   opened               → { signal: "email_opened" }
+ *   clicked              → { signal: "email_clicked" }
+ *   replied              → { signal: "email_replied" } (or linkedin_replied / whatsapp_replied)
+ *   meetingBooked        → { signal: "meeting_booked" }
+ *   emailsUnsubscribed   → { signal: "email_unsubscribed" }
+ *   aircallDone          → out of scope (no Aircall integration)
+ * Negate any leaf with present:false (e.g. "no email on file" = { has_column: "email", present: false }).
+ *
+ * A CONTACT leaf `{ has_contact: "email" | "linkedin" | "phone", present? }` asks
+ * whether the step that channel needs could reach the lead, resolved exactly as
+ * dispatch resolves it: email and phone through the sequence's mapped column with
+ * the built-in fallbacks, LinkedIn through the profile captured at enrollment. It
+ * is what "If has email / LinkedIn / phone" in the builder writes, so one campaign
+ * can route every lead instead of splitting the audience by data.
+ */
+export const SEQUENCE_CONTACT_CHANNELS = ["email", "linkedin", "phone"];
+/**
+ * Resolve a lead's reachable contacts the way dispatch does: the mapped email or
+ * phone column first, then the built-in keys, and LinkedIn from the profile the
+ * enrollment captured (a row value alone never makes a LinkedIn step sendable).
+ */
+export function sequenceLeadContacts(input) {
+    const phoneKey = input.settings?.phone_column_key ?? null;
+    return {
+        email: recipientEmailFromRow(input.rowValues, input.settings?.email_column_key ?? null) !== null,
+        linkedin: input.linkedin,
+        phone: callPhoneFromRow(input.rowValues, phoneKey) !== null || whatsAppAttendeeIdFromRow(input.rowValues, phoneKey) !== null,
+    };
+}
 const MAX_SEQUENCE_STEPS = 50;
 const MAX_TEMPLATE_LENGTH = 8_000;
 // The Premium ceiling, and only an authoring hint: the limit that actually
@@ -835,7 +883,7 @@ function collectConditionSignals(condition, out) {
     // it contributes nothing — and must be handled BEFORE the not-fallthrough below
     // (which would otherwise read condition.not off a data leaf). This is also why
     // the native-untracked engagement-gate walker never trips on a has_column branch.
-    else if ("has_column" in condition)
+    else if ("has_column" in condition || "has_contact" in condition)
         return;
     else if ("all" in condition)
         condition.all.forEach((c) => collectConditionSignals(c, out));
@@ -1810,6 +1858,13 @@ function normalizeCondition(raw, path, issues, depth = 0) {
             return undefined;
         return { has_column: key, present: raw.present === false ? false : true };
     }
+    if (raw.has_contact !== undefined) {
+        if (typeof raw.has_contact !== "string" || !SEQUENCE_CONTACT_CHANNELS.includes(raw.has_contact)) {
+            issues.push({ path: `${path}.has_contact`, message: `has_contact must be one of ${SEQUENCE_CONTACT_CHANNELS.join(", ")}.` });
+            return undefined;
+        }
+        return { has_contact: raw.has_contact, present: raw.present === false ? false : true };
+    }
     if (Array.isArray(raw.all)) {
         return { all: normalizeConditionList(raw.all, `${path}.all`, issues, depth) };
     }
@@ -1820,7 +1875,7 @@ function normalizeCondition(raw, path, issues, depth = 0) {
         const inner = normalizeCondition(raw.not, `${path}.not`, issues, depth + 1);
         return inner ? { not: inner } : undefined;
     }
-    issues.push({ path, message: "condition must be {signal}, {has_column}, {all}, {any}, or {not}." });
+    issues.push({ path, message: "condition must be {signal}, {has_column}, {has_contact}, {all}, {any}, or {not}." });
     return undefined;
 }
 function normalizeConditionList(raw, path, issues, depth) {
@@ -2103,9 +2158,10 @@ export function sequenceTemplateVariables(definition) {
  * `rowValues` is optional and backward-compatible: when omitted (undefined), a data
  * leaf ({ has_column }) evaluates as ABSENT — present:false matches, present:true
  * does not — so an existing signal-only caller is unaffected. Signal leaves ignore
- * rowValues entirely.
+ * rowValues entirely. A contact leaf ({ has_contact }) reads `contacts`; without
+ * it, the contact counts as absent.
  */
-export function evaluateSequenceCondition(condition, firedSignals, rowValues) {
+export function evaluateSequenceCondition(condition, firedSignals, rowValues, contacts) {
     const fired = firedSignals instanceof Set ? firedSignals : new Set(firedSignals);
     if ("signal" in condition) {
         const present = fired.has(condition.signal);
@@ -2115,11 +2171,15 @@ export function evaluateSequenceCondition(condition, firedSignals, rowValues) {
         const present = rowValueIsPresent(rowValues?.[condition.has_column]);
         return condition.present === false ? !present : present;
     }
+    if ("has_contact" in condition) {
+        const present = contacts?.[condition.has_contact] === true;
+        return condition.present === false ? !present : present;
+    }
     if ("all" in condition)
-        return condition.all.every((c) => evaluateSequenceCondition(c, fired, rowValues));
+        return condition.all.every((c) => evaluateSequenceCondition(c, fired, rowValues, contacts));
     if ("any" in condition)
-        return condition.any.some((c) => evaluateSequenceCondition(c, fired, rowValues));
-    return !evaluateSequenceCondition(condition.not, fired, rowValues);
+        return condition.any.some((c) => evaluateSequenceCondition(c, fired, rowValues, contacts));
+    return !evaluateSequenceCondition(condition.not, fired, rowValues, contacts);
 }
 /**
  * Whether a lead's row_values value counts as "present" for a data-leaf branch: a

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

@@ -29,6 +29,8 @@ export declare function teammatesAvailableTo(env: Record<string, string | undefi
 export declare const DEFAULT_TEAMMATE_SLUG = "workspace";
 /** What an Oxygent is called until someone names it, as Grok Bot's are (Tim, 2026-10-13). */
 export declare const NEW_TEAMMATE_NAME = "New Bot";
+/** What the first Oxygent is called until someone renames it (Philipp, 2026-10-19). */
+export declare const DEFAULT_TEAMMATE_NAME = "Oxygent";
 export declare const TEAMMATE_NAME_MAX_CHARS = 80;
 export declare const TEAMMATE_DESCRIPTION_MAX_CHARS = 500;
 /**
@@ -79,7 +81,7 @@ export declare function teammateDefaultLook(slug: string): {
 };
 /**
  * How an Oxygent presents: its name, what it does and its look. The first
- * Oxygent is "New Bot" until its owner names it; nothing renames the stored
+ * Oxygent is "Oxygent" until its owner names it; nothing renames the stored
  * Agent to get there, and the Workspace Agent's stock description is no job.
  */
 export declare function teammatePresentation(agent: {

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

@@ -30,6 +30,8 @@ export function teammatesAvailableTo(env, viewer) {
 export const DEFAULT_TEAMMATE_SLUG = "workspace";
 /** What an Oxygent is called until someone names it, as Grok Bot's are (Tim, 2026-10-13). */
 export const NEW_TEAMMATE_NAME = "New Bot";
+/** What the first Oxygent is called until someone renames it (Philipp, 2026-10-19). */
+export const DEFAULT_TEAMMATE_NAME = "Oxygent";
 const LEGACY_WORKSPACE_AGENT_NAME = "Workspace Agent";
 const LEGACY_WORKSPACE_AGENT_DESCRIPTION = "General organization-grounded workspace worker.";
 export const TEAMMATE_NAME_MAX_CHARS = 80;
@@ -103,12 +105,12 @@ export function teammateDefaultLook(slug) {
 }
 /**
  * How an Oxygent presents: its name, what it does and its look. The first
- * Oxygent is "New Bot" until its owner names it; nothing renames the stored
+ * Oxygent is "Oxygent" until its owner names it; nothing renames the stored
  * Agent to get there, and the Workspace Agent's stock description is no job.
  */
 export function teammatePresentation(agent) {
     const first = agent.slug === DEFAULT_TEAMMATE_SLUG;
-    const name = first && agent.name === LEGACY_WORKSPACE_AGENT_NAME ? NEW_TEAMMATE_NAME : agent.name;
+    const name = first && agent.name === LEGACY_WORKSPACE_AGENT_NAME ? DEFAULT_TEAMMATE_NAME : agent.name;
     const stored = agent.description?.trim() ?? "";
     const description = first && stored === LEGACY_WORKSPACE_AGENT_DESCRIPTION ? "" : stored;
     const look = teammateDefaultLook(agent.slug);