@oxygen-agent/cli 1.1010.954 → 1.1011.95

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

@@ -1032,6 +1032,84 @@ export function sequenceChannels(definition) {
  * stored under `draft`. Empty means nothing to send, so starting would
  * either dispatch a blank message or fail per lead at send time.
  */
+/**
+ * Threaded email steps that would continue another inbox's thread. A provider
+ * thread belongs to the mailbox that opened it, so a step that changes From —
+ * an exact-inbox step, or the return to the lead's assigned inbox after one —
+ * must open a new thread under its own subject. Checked on save and again at
+ * launch, because a draft may be saved half-written.
+ */
+export function sequenceSenderThreadConflicts(steps) {
+    const conflicts = [];
+    let precedingSender;
+    let seenEmail = false;
+    steps.forEach((step, index) => {
+        if (step.kind !== "email_send" && step.kind !== "email_reply")
+            return;
+        const sender = step.kind === "email_send" ? step.sender_mailbox_id : undefined;
+        if (seenEmail && sequenceEmailStepThreads(step) && sender !== precedingSender) {
+            conflicts.push({
+                index,
+                stepId: step.id,
+                message: `step '${step.id}' changes the sending inbox. Give it a new subject to start a new thread.`,
+            });
+        }
+        seenEmail = true;
+        precedingSender = sender;
+    });
+    return conflicts;
+}
+/** LinkedIn kinds that open or continue a conversation, so bind the lead to one account. */
+export const LINKEDIN_RELATIONSHIP_STEP_KINDS = new Set(["invite", "message", "inmail", "withdraw_invite"]);
+/** LinkedIn light touches: they bind nothing, so each may come from any selected person. */
+export const LINKEDIN_LIGHT_TOUCH_STEP_KINDS = new Set(["visit_profile", "follow", "like_post", "comment_post"]);
+const LINKEDIN_SENDER_STEP_KINDS = new Set([...LINKEDIN_RELATIONSHIP_STEP_KINDS, ...LINKEDIN_LIGHT_TOUCH_STEP_KINDS]);
+function normalizeLinkedInStepSender(value, path, issues) {
+    if (value === undefined || value === null || value === "")
+        return {};
+    if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value.trim())) {
+        issues.push({ path, message: "must be a sender profile id." });
+        return {};
+    }
+    return { sender_profile_id: value.trim() };
+}
+function stepSenderProfileId(step) {
+    return "sender_profile_id" in step && typeof step.sender_profile_id === "string" ? step.sender_profile_id : undefined;
+}
+/**
+ * The person who owns every lead's LinkedIn conversation in this journey, when
+ * the relationship steps name one (null = each lead's assigned person). Only
+ * meaningful once sequenceLinkedInOwnerConflicts is empty.
+ */
+export function sequenceLinkedInOwnerProfileId(steps) {
+    for (const step of steps) {
+        if (!LINKEDIN_RELATIONSHIP_STEP_KINDS.has(step.kind))
+            continue;
+        const owner = stepSenderProfileId(step);
+        if (owner)
+            return owner;
+    }
+    return null;
+}
+/**
+ * Relationship steps that disagree about who sends them. LinkedIn lets one of
+ * the workspace's accounts hold a conversation with a lead (and OXYGEN binds
+ * the lead to the first account that invites or messages it), so a connection
+ * request from one person followed by a message from another would be refused.
+ */
+export function sequenceLinkedInOwnerConflicts(steps) {
+    const relationship = steps
+        .map((step, index) => ({ step, index }))
+        .filter(({ step }) => LINKEDIN_RELATIONSHIP_STEP_KINDS.has(step.kind));
+    const owners = new Set(relationship.map(({ step }) => stepSenderProfileId(step) ?? ""));
+    if (owners.size <= 1)
+        return [];
+    return relationship.map(({ step, index }) => ({
+        index,
+        stepId: step.id,
+        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.`,
+    }));
+}
 export function sequenceStepsMissingCopy(steps) {
     const missing = [];
     const check = (step, field, value) => {
@@ -1174,6 +1252,12 @@ export function validateSequenceDefinition(input, options = {}) {
                 message: `step '${step.id}' has no subject, which means "continue the previous email" — but no earlier step sends one. Give the first email of the sequence a subject.`,
             });
         });
+        for (const conflict of sequenceSenderThreadConflicts(normalized)) {
+            issues.push({ path: `steps[${conflict.index}].subject_template`, message: conflict.message });
+        }
+        for (const conflict of sequenceLinkedInOwnerConflicts(normalized)) {
+            issues.push({ path: `steps[${conflict.index}].sender_profile_id`, message: conflict.message });
+        }
     }
     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 });
@@ -1298,14 +1382,17 @@ raw, index, options, issues) {
     if (channel && options.allowedChannels && !options.allowedChannels.includes(channel)) {
         issues.push({ path: `${path}.channel`, message: `channel '${channel}' is not enabled for this sequence.` });
     }
+    const linkedInSender = LINKEDIN_SENDER_STEP_KINDS.has(stepKind)
+        ? normalizeLinkedInStepSender(raw.sender_profile_id, `${path}.sender_profile_id`, issues)
+        : {};
     switch (stepKind) {
         case "visit_profile":
-            return { id, channel: "linkedin", kind: "visit_profile" };
+            return { id, channel: "linkedin", kind: "visit_profile", ...linkedInSender };
         case "invite": {
             const note = optionalTemplate(raw.note_template, `${path}.note_template`, MAX_NOTE_LENGTH, issues);
             return note !== undefined
-                ? { id, channel: "linkedin", kind: "invite", note_template: note }
-                : { id, channel: "linkedin", kind: "invite" };
+                ? { id, channel: "linkedin", kind: "invite", note_template: note, ...linkedInSender }
+                : { id, channel: "linkedin", kind: "invite", ...linkedInSender };
         }
         case "wait_for_connection": {
             const timeoutDays = raw.timeout_days === undefined || raw.timeout_days === null
@@ -1325,7 +1412,7 @@ raw, index, options, issues) {
             const autoOptimize = normalizeAutoOptimize(raw.auto_optimize, `${path}.auto_optimize`, variants, options, issues);
             const attachments = normalizeLinkedInAttachments(raw.attachments, `${path}.attachments`, issues);
             return {
-                id, channel: "linkedin", kind: "message", template: template ?? "",
+                id, channel: "linkedin", kind: "message", template: template ?? "", ...linkedInSender,
                 ...(variants ? { variants: variants } : {}),
                 ...(autoOptimize ? { auto_optimize: autoOptimize } : {}),
                 ...(attachments ? { attachments } : {}),
@@ -1337,7 +1424,7 @@ raw, index, options, issues) {
             const variants = normalizeVariants(raw.variants, `${path}.variants`, ["subject_template", "template"], issues, options.draft === true);
             const autoOptimize = normalizeAutoOptimize(raw.auto_optimize, `${path}.auto_optimize`, variants, options, issues);
             return {
-                id, channel: "linkedin", kind: "inmail", subject_template: subject ?? "", template: template ?? "",
+                id, channel: "linkedin", kind: "inmail", subject_template: subject ?? "", template: template ?? "", ...linkedInSender,
                 ...(variants ? { variants: variants } : {}),
                 ...(autoOptimize ? { auto_optimize: autoOptimize } : {}),
             };
@@ -1372,8 +1459,13 @@ raw, index, options, issues) {
             const cc = optionalEmailList(raw.cc, `${path}.cc`, issues);
             const bcc = optionalEmailList(raw.bcc, `${path}.bcc`, issues);
             const sendWindow = normalizeSendWindow(raw.send_window, `${path}.send_window`, issues);
+            const senderMailboxId = optionalString(raw.sender_mailbox_id, `${path}.sender_mailbox_id`, issues);
+            if (senderMailboxId && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(senderMailboxId)) {
+                issues.push({ path: `${path}.sender_mailbox_id`, message: "must be an inbox id." });
+            }
             return {
                 id, channel: "email", kind: "email_send",
+                ...(senderMailboxId ? { sender_mailbox_id: senderMailboxId } : {}),
                 ...(threaded ? {} : { subject_template: subject }),
                 body_template: body ?? "",
                 ...(bodyHtml !== undefined ? { body_html_template: bodyHtml } : {}),
@@ -1557,7 +1649,7 @@ raw, index, options, issues) {
             };
         }
         case "follow":
-            return { id, channel: "linkedin", kind: "follow" };
+            return { id, channel: "linkedin", kind: "follow", ...linkedInSender };
         case "like_post": {
             const reaction = typeof raw.reaction === "string" && LINKEDIN_POST_REACTION_SET.has(raw.reaction)
                 ? raw.reaction
@@ -1567,7 +1659,7 @@ raw, index, options, issues) {
             }
             const recency = optionalPostRecencyDays(raw.post_recency_days, `${path}.post_recency_days`, issues);
             return {
-                id, channel: "linkedin", kind: "like_post",
+                id, channel: "linkedin", kind: "like_post", ...linkedInSender,
                 ...(reaction ? { reaction: reaction } : {}),
                 ...(recency !== undefined ? { post_recency_days: recency } : {}),
                 ...(raw.on_no_post === "stop" ? { on_no_post: "stop" } : {}),
@@ -1587,7 +1679,7 @@ raw, index, options, issues) {
             }
             const recency = optionalPostRecencyDays(raw.post_recency_days, `${path}.post_recency_days`, issues);
             return {
-                id, channel: "linkedin", kind: "comment_post",
+                id, channel: "linkedin", kind: "comment_post", ...linkedInSender,
                 ...(hasText ? { text_template: textTemplate } : {}),
                 ...(hasPrompt ? { ai_prompt: aiPrompt } : {}),
                 ...(recency !== undefined ? { post_recency_days: recency } : {}),
@@ -1595,7 +1687,7 @@ raw, index, options, issues) {
             };
         }
         case "withdraw_invite":
-            return { id, channel: "linkedin", kind: "withdraw_invite" };
+            return { id, channel: "linkedin", kind: "withdraw_invite", ...linkedInSender };
         case "stop":
             return { id, kind: "stop" };
         default:

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

@@ -15,6 +15,7 @@ export type SignupLeadWebhookInput = {
         email?: string | null;
         firstName?: string | null;
         lastName?: string | null;
+        phone?: 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;

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

@@ -33,6 +33,7 @@ export function buildSignupLeadWebhookPayload(input) {
     const email = normalizeString(input.user?.email)?.toLowerCase() ?? null;
     const firstName = normalizeString(input.user?.firstName);
     const lastName = normalizeString(input.user?.lastName);
+    const phone = normalizeString(input.user?.phone);
     const fullName = normalizeString([firstName, lastName].filter(Boolean).join(" "));
     const clerkOrgId = normalizeString(input.organization?.clerkOrgId);
     const companyName = normalizeString(input.organization?.name);
@@ -51,6 +52,7 @@ export function buildSignupLeadWebhookPayload(input) {
         email,
         first_name: firstName,
         last_name: lastName,
+        phone,
         full_name: fullName,
         created_at: normalizeDate(input.user?.createdAt),
         linkedin_url: normalizeString(input.user?.linkedinUrl) ?? undefined,
@@ -118,6 +120,7 @@ export function buildSignupLeadWebhookPayload(input) {
         email,
         first_name: firstName,
         last_name: lastName,
+        phone,
         full_name: fullName,
         company_name: companyName,
         company_domain: companyDomain,

package/node_modules/@oxygen/shared/dist/table-capacity.d.ts

@@ -37,9 +37,8 @@ export declare const PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST: readonly PlanB
  * - A limit that tightens (free, $49, $99) is a scheduled 2026-09 repricing value
  *   (`storage.<band>.*` in `REPRICING_2026_09_SCHEDULE`): today's envelope until
  *   the effective-date switch, the ratified ladder from it on.
- * - A band awaiting the rows-per-Table capacity test has its ladder workspace
- *   totals and keeps today's rows per Table, except on the self-hosted dev
- *   deployment, where the test runs.
+ * - A band awaiting a passing rows-per-Table capacity test has its ladder
+ *   workspace totals and keeps today's rows per Table everywhere.
  * - Every other band is already at its ladder value.
  */
 export declare function resolveWorkspaceTableCapacity(band: PlanBand, options?: RepricingOptions): WorkspaceTableCapacityLimits;

package/node_modules/@oxygen/shared/dist/table-capacity.js

@@ -50,18 +50,13 @@ export const PLAN_BAND_TABLE_CAPACITY_TARGETS = Object.freeze({
  */
 export const PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST = Object.freeze(["999", "1999"]);
 /**
- * The capacity test itself runs on the self-hosted dev deployment, which
- * therefore applies the awaiting bands' full ladder: a 10,000,000-row Table
- * cannot be measured behind a 3,000,000-row limit. Every other deployment,
- * production included, keeps the list above. The exact selector is compared
- * (not `resolveDeployEnv`, which throws on a typo) so a malformed value keeps
- * the production answer instead of failing a limits read.
+ * The dev capacity test has finished without meeting the latency and export
+ * requirements (decision F.9). Hold the same 3M limit in every environment;
+ * the earlier dev-only 5M/10M override made limits reads promise a capacity
+ * that the founder held after that test.
  */
-function awaitsTableRowCapacityTest(band, options) {
-    if (!PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST.includes(band))
-        return false;
-    const env = options.env ?? process.env;
-    return env.OXYGEN_DEPLOY_ENV?.trim().toLowerCase() !== "selfhost-dev";
+function awaitsTableRowCapacityTest(band) {
+    return PLAN_BANDS_AWAITING_TABLE_ROW_CAPACITY_TEST.includes(band);
 }
 const STORAGE_FIELDS = [
     ["tableRowLimit", "table_row_limit"],
@@ -75,14 +70,13 @@ const STORAGE_FIELDS = [
  * - A limit that tightens (free, $49, $99) is a scheduled 2026-09 repricing value
  *   (`storage.<band>.*` in `REPRICING_2026_09_SCHEDULE`): today's envelope until
  *   the effective-date switch, the ratified ladder from it on.
- * - A band awaiting the rows-per-Table capacity test has its ladder workspace
- *   totals and keeps today's rows per Table, except on the self-hosted dev
- *   deployment, where the test runs.
+ * - A band awaiting a passing rows-per-Table capacity test has its ladder
+ *   workspace totals and keeps today's rows per Table everywhere.
  * - Every other band is already at its ladder value.
  */
 export function resolveWorkspaceTableCapacity(band, options = {}) {
     const target = PLAN_BAND_TABLE_CAPACITY_TARGETS[band];
-    if (awaitsTableRowCapacityTest(band, options)) {
+    if (awaitsTableRowCapacityTest(band)) {
         return Object.freeze({ ...target, tableRowLimit: WORKSPACE_TABLE_CAPACITY.tableRowLimit });
     }
     const resolved = { ...target };
@@ -95,7 +89,7 @@ export function resolveWorkspaceTableCapacity(band, options = {}) {
     return Object.freeze(resolved);
 }
 export function describeWorkspaceTableCapacityStatus(band, options = {}) {
-    if (awaitsTableRowCapacityTest(band, options)) {
+    if (awaitsTableRowCapacityTest(band)) {
         return { status: "awaiting_capacity_test", effectiveAt: null, target: PLAN_BAND_TABLE_CAPACITY_TARGETS[band] };
     }
     const state = readRepricingSwitch(options);

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

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1010.954";
+export declare const OXYGEN_BUILD_VERSION = "1.1011.95";

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

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1010.954";
+export const OXYGEN_BUILD_VERSION = "1.1011.95";

package/node_modules/@oxygen/shared/dist/workspace-file-storage.d.ts

@@ -79,3 +79,9 @@ export declare function putWorkspaceFileObject(input: {
     sizeBytes: number;
     sha256: string;
 }>;
+/** Delete only an object key already proven to belong to this workspace file. */
+export declare function deleteWorkspaceFileObject(input: {
+    organizationId: string;
+    fileId: string;
+    storageKey: string;
+}): Promise<void>;

package/node_modules/@oxygen/shared/dist/workspace-file-storage.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
-import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { OxygenError } from "./cli-result.js";
 import { resolveObjectStorageClient } from "./object-storage.js";
@@ -171,3 +171,11 @@ export async function putWorkspaceFileObject(input) {
     await readWorkspaceFileObject({ ...input, storageKey, sizeBytes: bytes.byteLength, sha256 });
     return { storageKey, sizeBytes: bytes.byteLength, sha256 };
 }
+/** Delete only an object key already proven to belong to this workspace file. */
+export async function deleteWorkspaceFileObject(input) {
+    assertWorkspaceFileObjectKey(input);
+    const { client, bucket } = resolveObjectStorageClient();
+    await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: input.storageKey }), {
+        abortSignal: AbortSignal.timeout(STORAGE_TIMEOUT_MS),
+    });
+}

package/node_modules/@oxygen/shared/package.json

@@ -121,6 +121,11 @@
       "import": "./dist/dnc-identities.js",
       "default": "./dist/dnc-identities.js"
     },
+    "./company-reply-pause": {
+      "types": "./dist/company-reply-pause.d.ts",
+      "import": "./dist/company-reply-pause.js",
+      "default": "./dist/company-reply-pause.js"
+    },
     "./provider-funding-errors": {
       "types": "./dist/provider-funding-errors.d.ts",
       "import": "./dist/provider-funding-errors.js",

package/node_modules/@oxygen/workflows/dist/graph/lint.js

@@ -812,7 +812,7 @@ function lintToolNode(node, path, add, scope, options) {
         add(`${path}.mode`, "invalid_step_mode", "Node mode is invalid.");
     }
     else if (node.mode !== undefined && (node.effect !== "external_write" || node.mode !== "dry_run")) {
-        add(`${path}.mode`, "unsupported_step_mode", "A tool-node mode is only supported as 'dry_run' on an external write.");
+        add(`${path}.mode`, "unsupported_step_mode", "Omit mode to run this step live. The only mode a tool node may set is 'dry_run', on an external write, and it previews without writing.");
     }
     if (node.effect === "external_write" && node.retry !== undefined) {
         add(`${path}.retry`, "unsafe_external_write_retry", "External writes cannot have a node retry policy because an ambiguous failure may already have landed.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxygen-agent/cli",
-  "version": "1.1010.954",
+  "version": "1.1011.95",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",