@oxygen-agent/cli 1.844.6 → 1.845.0

package/README.md

@@ -34,4 +34,4 @@ oxygen update
 
 For product documentation, visit https://oxygen-agent.com/docs. For support, visit https://oxygen-agent.com.
 
-Version: 1.844.6
+Version: 1.845.0

package/dist/index.js

@@ -12342,7 +12342,7 @@ fixed scan; watermark_cursor starts a later bounded replay. Consumers must retai
         }
     }))
         .addCommand(new Command("update")
-        .description("Update a sequence. Journey definition/channels/email binding are draft-only so revised scope receives a fresh launch approval; sender pools can change while draft or paused; launch caps change through `sequences start` after first start. Name, throttles, tags, and open/click tracking toggles remain editable as allowed by the server. Pass only the fields you want to change.")
+        .description("Update a sequence. Journey structure/channels/email binding are draft-only so revised scope receives a fresh launch approval; a started sequence still accepts a definition that changes nothing but its wait steps (the delays between steps, including the one before step 1); sender pools can change while draft or paused; launch caps change through `sequences start` after first start. Name, throttles, tags, and open/click tracking toggles remain editable as allowed by the server. Pass only the fields you want to change.")
         .argument("<sequence>", "Sequence id or slug.")
         .option("--name <name>", "New human-readable sequence name.")
         .option("--steps-file <path>", "Draft only: path to a JSON file: { \"steps\": [...] } replacing the journey. Copy supports {{column}} interpolation; native email steps also expose {{sender_name}} / {{sender_first_name}} / {{sender_email}} from the sending mailbox (a same-named row column wins). A `branch` can also route on the lead's data with a data leaf { has_column: \"email\" } (true when that row_values column is non-empty; present:false for \"missing\").")

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

@@ -815,6 +815,22 @@ export declare function sequenceWaitStepJitterMs(step: SequenceWaitStep, enrollm
  * spreads a same-instant batch across the jitter window.
  */
 export declare function sequenceWaitStepDelayWithJitterMs(step: SequenceWaitStep, enrollmentId: string): number;
+/**
+ * Whether `after` changes nothing about `before` except its timing — the delays
+ * between steps, including the lead-in delay in front of the very first one.
+ *
+ * This is the one journey edit a LIVE sequence accepts. The journey lock exists
+ * so a revised journey gets a fresh launch preview and approval, and a wait
+ * provably cannot move that preview: estimateSequenceActions (the start route's
+ * estimator) skips every step with no channel, so waits contribute nothing to the
+ * planned actions, the channel mix, or the credit estimate the approval was
+ * granted against. What a delay does change is when the next step fires — exactly
+ * the knob a founder reaches for after watching day one of a live campaign.
+ *
+ * Inserting or removing a wait counts as timing too: a wait dispatches nothing, so
+ * adding one only postpones a send and removing one only brings it forward.
+ */
+export declare function sequenceDefinitionsDifferOnlyInTiming(before: SequenceDefinition, after: SequenceDefinition): boolean;
 /**
  * Render a sequence-copy template against a row's values. Delegates to the shared
  * deterministic engine (sequence-template.ts): `{{column}}` substitution plus

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

@@ -1835,6 +1835,86 @@ export function sequenceWaitStepJitterMs(step, enrollmentId) {
 export function sequenceWaitStepDelayWithJitterMs(step, enrollmentId) {
     return sequenceWaitStepDelayMs(step) + sequenceWaitStepJitterMs(step, enrollmentId);
 }
+/**
+ * Branch fields that name another step. A signal branch spells its arms `then`/
+ * `else`; a connection branch spells them `then_id`/`else_id`. Both are erased
+ * from the skeleton and replaced by one normalized pair, so an arm that is absent
+ * on one side and explicitly null on the other still compares equal.
+ */
+const BRANCH_TARGET_KEYS = ["then", "else", "then_id", "else_id"];
+/** Key-sorted JSON, so two structurally equal definitions compare equal whatever order their keys were built in. */
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+        return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+/**
+ * The definition with every `wait` step erased: the actions, in order, with each
+ * branch arm repointed to the step its delay leads INTO. Two definitions share a
+ * skeleton exactly when they perform the same journey and differ only in when.
+ *
+ * Waits are folded rather than simply filtered out because a delay is modelled as
+ * a step, so an arm whose delay was edited legitimately repoints from one wait id
+ * to another (setBranchArmDelay in the web builder does exactly that) — a naive
+ * filter would read that as a rerouted branch.
+ */
+function sequenceTimingSkeleton(definition) {
+    const steps = Array.isArray(definition?.steps) ? definition.steps : [];
+    const indexById = new Map(steps.map((step, index) => [step.id, index]));
+    // The first non-wait step at or after `id`. A dangling target, an absent one,
+    // and a trailing run of waits all end the path — all resolve to null.
+    const throughWaits = (id) => {
+        if (typeof id !== "string")
+            return null;
+        const from = indexById.get(id);
+        if (from === undefined)
+            return null;
+        for (let k = from; k < steps.length; k++) {
+            const step = steps[k];
+            if (step.kind !== "wait")
+                return step.id;
+        }
+        return null;
+    };
+    const actions = steps
+        .filter((step) => step.kind !== "wait")
+        .map((step) => {
+        const fields = { ...step };
+        const branch = step;
+        for (const key of BRANCH_TARGET_KEYS)
+            delete fields[key];
+        return {
+            ...fields,
+            arm_then: throughWaits(branch.then ?? branch.then_id),
+            arm_else: throughWaits(branch.else ?? branch.else_id),
+        };
+    });
+    return stableJson(actions);
+}
+/**
+ * Whether `after` changes nothing about `before` except its timing — the delays
+ * between steps, including the lead-in delay in front of the very first one.
+ *
+ * This is the one journey edit a LIVE sequence accepts. The journey lock exists
+ * so a revised journey gets a fresh launch preview and approval, and a wait
+ * provably cannot move that preview: estimateSequenceActions (the start route's
+ * estimator) skips every step with no channel, so waits contribute nothing to the
+ * planned actions, the channel mix, or the credit estimate the approval was
+ * granted against. What a delay does change is when the next step fires — exactly
+ * the knob a founder reaches for after watching day one of a live campaign.
+ *
+ * Inserting or removing a wait counts as timing too: a wait dispatches nothing, so
+ * adding one only postpones a send and removing one only brings it forward.
+ */
+export function sequenceDefinitionsDifferOnlyInTiming(before, after) {
+    return sequenceTimingSkeleton(before) === sequenceTimingSkeleton(after);
+}
 /**
  * Render a sequence-copy template against a row's values. Delegates to the shared
  * deterministic engine (sequence-template.ts): `{{column}}` substitution plus

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

@@ -1,4 +1,4 @@
-export declare const OXYGEN_VERSION = "1.844.6";
+export declare const OXYGEN_VERSION = "1.845.0";
 export declare const OXYGEN_MINIMUM_CLI_VERSION = "1.181.0";
 export declare const MANAGED_INBOX_MINIMUM_CLI_VERSION = "1.326.2";
 export declare const SUPPORT_AGENT_REPLY_MINIMUM_CLI_VERSION = "1.747.0";

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

@@ -1,4 +1,4 @@
-export const OXYGEN_VERSION = "1.844.6";
+export const OXYGEN_VERSION = "1.845.0";
 // The GLOBAL CLI compatibility floor: the oldest CLI allowed to call any
 // operational route. Raising it hard-rejects every older CLI from the entire
 // product, so it obeys one law, enforced by scripts/ci/cli-min-version-gate.mjs:

package/package.json

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