@dench.com/cli 3.8.0-staging.389 → 3.8.2-staging.391

package/lib/campaign-steps.ts

@@ -6,7 +6,10 @@ export const MAX_CONNECTION_NOTE_CHARS = 300;
 export const MAX_INMAIL_SUBJECT_CHARS = 200;
 export const MAX_INMAIL_BODY_CHARS = 1900;
 export const MAX_LIKE_POST_AGE_DAYS = 365;
+export const MAX_LIKE_POST_COUNT = 3;
 export const MIN_WITHDRAW_AFTER_HOURS = 7 * 24;
+export const MIN_ACCEPTANCE_WAIT_HOURS = 24;
+export const MAX_ACCEPTANCE_WAIT_HOURS = 90 * 24;
 export const LINKEDIN_REACTIONS = [
   "like",
   "celebrate",
@@ -24,10 +27,36 @@ export const STEP_TYPES = [
   "linkedin_visit",
   "linkedin_like_post",
   "linkedin_inmail",
+  "condition",
+  "wait_for_connection",
 ] as const;
 
 export type StepType = (typeof STEP_TYPES)[number];
 
+/** Workflow steps that send nothing and continue on a Yes or a No path. */
+export const BRANCH_STEP_TYPES = ["condition", "wait_for_connection"] as const;
+
+export const WORKFLOW_END = "end";
+
+export const CONDITION_CHECKS = [
+  "linkedin_connected",
+  "has_email",
+  "opened_last_email",
+  "field_value",
+] as const;
+
+export const CONDITION_OPERATORS = [
+  "is",
+  "is_not",
+  "is_empty",
+  "is_not_empty",
+  "contains",
+] as const;
+
+export function isBranchStep(type: unknown): boolean {
+  return (BRANCH_STEP_TYPES as readonly unknown[]).includes(type);
+}
+
 export const STEP_KEYS = [
   "type",
   "waitHours",
@@ -43,11 +72,41 @@ export const STEP_KEYS = [
   "connectionTimeoutHours",
   "likeReaction",
   "likeMaxPostAgeDays",
+  "likeSkipPreviousWait",
   "likeSkipNextWait",
+  "likeCount",
   "inmailSubject",
   "withdrawAfterHours",
+  "key",
+  "next",
+  "yesNext",
+  "noNext",
+  "check",
+  "conditionField",
+  "conditionOperator",
+  "conditionValue",
 ] as const;
 
+/** A workflow step's id and where each of its exits leads. */
+export const PATH_KEYS = ["key", "next", "yesNext", "noNext"] as const;
+
+/** Fixed once a campaign launches: its paths and what each If / else checks. */
+export const FROZEN_AFTER_LAUNCH = [
+  ...PATH_KEYS,
+  "check",
+  "conditionField",
+  "conditionOperator",
+] as const;
+
+/** Steps with an id, a path or an If / else / acceptance wait make a workflow. */
+export function hasWorkflowShape(step: unknown): boolean {
+  if (!step || typeof step !== "object") return false;
+  const row = step as Record<string, unknown>;
+  return (
+    PATH_KEYS.some((key) => row[key] !== undefined) || isBranchStep(row.type)
+  );
+}
+
 const FIELDS_BY_TYPE: Record<StepType, readonly string[]> = {
   wait: ["waitHours"],
   email: [
@@ -75,13 +134,23 @@ const FIELDS_BY_TYPE: Record<StepType, readonly string[]> = {
     "onlyIf",
     "likeReaction",
     "likeMaxPostAgeDays",
+    "likeSkipPreviousWait",
     "likeSkipNextWait",
+    "likeCount",
   ],
   linkedin_inmail: [
     "linkedinAccountId",
     "linkedinMessageBody",
     "inmailSubject",
   ],
+  condition: [
+    "linkedinAccountId",
+    "check",
+    "conditionField",
+    "conditionOperator",
+    "conditionValue",
+  ],
+  wait_for_connection: ["linkedinAccountId", "connectionTimeoutHours"],
 };
 
 const TEXT_FIELDS = [
@@ -92,6 +161,8 @@ const TEXT_FIELDS = [
   "linkedinAccountId",
   "linkedinMessageBody",
   "inmailSubject",
+  "conditionField",
+  "conditionValue",
 ] as const;
 
 const TEMPLATE_FIELDS = [
@@ -108,6 +179,11 @@ const MESSAGE_MODES = ["skip_if_not_connected", "wait_until_connected"];
 export type StepCheckOptions = {
   allowSingleBraces?: boolean;
   singleBraceOverride?: string;
+  /**
+   * The steps form a workflow (paths, If / else, Wait for them to accept).
+   * Unset, steps with a key, a path or a logic type make one.
+   */
+  workflow?: boolean;
 };
 
 export type StepIssue = { step: number; field?: string; message: string };
@@ -124,7 +200,7 @@ function holdsNothing(field: string, value: unknown): boolean {
 }
 
 export function singleBraceTokens(text: string): string[] {
-  const outside = text.replace(/\{\{[^{}]*\}\}/g, " ");
+  const outside = text.replace(/\{\{[^{}]*\}\}|\[\[[^[\]]*\]\]/g, " ");
   return [
     ...new Set(
       [...outside.matchAll(/\{\s*([A-Za-z_][A-Za-z0-9_ .-]{0,60}?)\s*\}/g)].map(
@@ -177,7 +253,7 @@ export function staleHtmlWarning(index: number): string {
 }
 
 function hasEmptyMergeToken(text: string): boolean {
-  return /\{\{\s*\}\}/.test(text);
+  return /\{\{\s*\}\}|\[\[\s*\]\]/.test(text);
 }
 
 function listSteps(numbers: number[]): string {
@@ -240,6 +316,25 @@ function checkStepFieldShapes(
       `${label}: "likeMaxPostAgeDays" must be a whole number from 1 to ${MAX_LIKE_POST_AGE_DAYS}.`,
       "likeMaxPostAgeDays",
     );
+  if (
+    row.likeCount !== undefined &&
+    (typeof row.likeCount !== "number" ||
+      !Number.isInteger(row.likeCount) ||
+      row.likeCount < 1 ||
+      row.likeCount > MAX_LIKE_POST_COUNT)
+  )
+    fail(
+      `${label}: "likeCount" must be a whole number from 1 to ${MAX_LIKE_POST_COUNT}.`,
+      "likeCount",
+    );
+  if (
+    row.likeSkipPreviousWait !== undefined &&
+    typeof row.likeSkipPreviousWait !== "boolean"
+  )
+    fail(
+      `${label}: "likeSkipPreviousWait" must be true or false.`,
+      "likeSkipPreviousWait",
+    );
   if (
     row.likeSkipNextWait !== undefined &&
     typeof row.likeSkipNextWait !== "boolean"
@@ -261,14 +356,22 @@ function checkStepFieldShapes(
       "withdrawAfterHours",
     );
 
+  checkLogicFieldShapes(row, label, fail);
+
   const kind = stepType === "email" ? "an email" : `a ${stepType}`;
   const allowed = FIELDS_BY_TYPE[stepType];
   const dropped = (STEP_KEYS as readonly string[]).filter(
     (key) =>
-      key !== "type" && !allowed.includes(key) && !holdsNothing(key, row[key]),
+      key !== "type" &&
+      !(PATH_KEYS as readonly string[]).includes(key) &&
+      !allowed.includes(key) &&
+      !holdsNothing(key, row[key]),
   );
+  if (stepType === "condition") dropped.push(...conditionDrops(row));
   for (const field of dropped) {
-    if (field === "onlyIf")
+    if (stepType === "condition" && allowed.includes(field))
+      fail(conditionDropMessage(row, field, label), field);
+    else if (field === "onlyIf")
       fail(
         `${label}: "onlyIf" only works on email or linkedin_like_post steps; ${kind} step would drop it. InMail already skips connected people.`,
         field,
@@ -286,6 +389,86 @@ function checkStepFieldShapes(
   }
 }
 
+const CHECK_NAMES: Record<string, string> = {
+  linkedin_connected: "whether they are connected on LinkedIn",
+  has_email: "whether they have an email address",
+  opened_last_email: "whether they opened the last email",
+};
+
+function checkLogicFieldShapes(
+  row: Record<string, unknown>,
+  label: string,
+  fail: Fail,
+): void {
+  for (const field of PATH_KEYS) {
+    const value = row[field];
+    if (value !== undefined && (typeof value !== "string" || !value.trim()))
+      fail(
+        field === "key"
+          ? `${label}: "key" must be a short text id, like "invite".`
+          : `${label}: "${field}" must be another step's "key", or "${WORKFLOW_END}" to stop there.`,
+        field,
+      );
+  }
+  if (
+    row.check !== undefined &&
+    !(CONDITION_CHECKS as readonly unknown[]).includes(row.check)
+  )
+    fail(
+      `${label}: "check" must be one of: ${CONDITION_CHECKS.join(", ")}.`,
+      "check",
+    );
+  if (
+    row.conditionOperator !== undefined &&
+    !(CONDITION_OPERATORS as readonly unknown[]).includes(row.conditionOperator)
+  )
+    fail(
+      `${label}: "conditionOperator" must be one of: ${CONDITION_OPERATORS.join(", ")}.`,
+      "conditionOperator",
+    );
+}
+
+function operatorTakesValue(operator: unknown): boolean {
+  return operator !== "is_empty" && operator !== "is_not_empty";
+}
+
+/** Condition fields the If / else's own check would drop. */
+function conditionDrops(row: Record<string, unknown>): string[] {
+  const drops: string[] = [];
+  // An edit that leaves "check" out keeps the stored one, unknown here.
+  if (row.check === undefined) return drops;
+  if (
+    row.check !== "linkedin_connected" &&
+    !holdsNothing("linkedinAccountId", row.linkedinAccountId)
+  )
+    drops.push("linkedinAccountId");
+  for (const field of ["conditionField", "conditionOperator"] as const)
+    if (row.check !== "field_value" && !holdsNothing(field, row[field]))
+      drops.push(field);
+  if (
+    !holdsNothing("conditionValue", row.conditionValue) &&
+    (row.check !== "field_value" || !operatorTakesValue(row.conditionOperator))
+  )
+    drops.push("conditionValue");
+  return drops;
+}
+
+function conditionDropMessage(
+  row: Record<string, unknown>,
+  field: string,
+  label: string,
+): string {
+  if (field === "linkedinAccountId")
+    return `${label}: "linkedinAccountId" is only kept on an If / else that checks "linkedin_connected", so it would be dropped.`;
+  if (field === "conditionValue" && row.check === "field_value")
+    return `${label}: "conditionValue" would be dropped, because "${String(row.conditionOperator)}" compares against nothing.`;
+  const checked =
+    typeof row.check === "string" && CHECK_NAMES[row.check]
+      ? ` This one checks ${CHECK_NAMES[row.check]}.`
+      : "";
+  return `${label}: "${field}" is only kept when "check" is "field_value", so it would be dropped.${checked}`;
+}
+
 function checkTemplateTokens(
   row: Record<string, unknown>,
   label: string,
@@ -297,7 +480,10 @@ function checkTemplateTokens(
     const text = row[field];
     if (typeof text !== "string") continue;
     if (hasEmptyMergeToken(text))
-      fail(`${label}: "${field}" has an empty {{ }} merge token.`, field);
+      fail(
+        `${label}: "${field}" has an empty merge token ({{ }} or [[ ]]).`,
+        field,
+      );
     if (options.allowSingleBraces) continue;
     const tokens = singleBraceTokens(text);
     if (tokens.length)
@@ -373,6 +559,146 @@ function checkTimeoutRange(timeout: unknown, label: string, fail: Fail): void {
     );
 }
 
+function checkCondition(
+  row: Record<string, unknown>,
+  label: string,
+  fail: Fail,
+): void {
+  if (row.check === undefined) {
+    fail(
+      `${label} is an If / else (condition) step and needs "check": ${CONDITION_CHECKS.join(", ")}.`,
+      "check",
+    );
+    return;
+  }
+  if (row.check !== "field_value") return;
+  if (!trimmedText(row.conditionField))
+    fail(
+      `${label} checks a lead field and needs "conditionField", the field's name (like "Job Title").`,
+      "conditionField",
+    );
+  if (row.conditionOperator === undefined)
+    fail(
+      `${label} checks a lead field and needs "conditionOperator": ${CONDITION_OPERATORS.join(", ")}.`,
+      "conditionOperator",
+    );
+  else if (
+    operatorTakesValue(row.conditionOperator) &&
+    !trimmedText(row.conditionValue)
+  )
+    fail(
+      `${label}: "conditionOperator": "${String(row.conditionOperator)}" needs "conditionValue", the text to compare the field with.`,
+      "conditionValue",
+    );
+}
+
+function checkAcceptanceWait(
+  timeout: unknown,
+  label: string,
+  fail: Fail,
+): void {
+  if (timeout === undefined) return;
+  if (
+    typeof timeout !== "number" ||
+    !Number.isFinite(timeout) ||
+    timeout < MIN_ACCEPTANCE_WAIT_HOURS ||
+    timeout > MAX_ACCEPTANCE_WAIT_HOURS
+  )
+    fail(
+      `${label}: "connectionTimeoutHours" must be ${MIN_ACCEPTANCE_WAIT_HOURS}-${MAX_ACCEPTANCE_WAIT_HOURS} hours (1-90 days) of waiting for them to accept.`,
+      "connectionTimeoutHours",
+    );
+}
+
+const BRANCH_NAMES: Record<string, { name: string; yes: string; no: string }> =
+  {
+    condition: { name: "If / else", yes: "Yes", no: "No" },
+    wait_for_connection: {
+      name: "Wait for them to accept",
+      yes: "Accepted",
+      no: "Not accepted",
+    },
+  };
+
+/**
+ * The paths a workflow's steps declare, step by step: unique keys, targets
+ * that exist, and the right exits for each kind of step. Whether every step
+ * is reachable and every path moves forward is checked when the steps save.
+ */
+function checkWorkflowPaths(
+  steps: readonly unknown[],
+  errors: StepIssue[],
+): void {
+  const rows = steps.map((value) =>
+    value && typeof value === "object" && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : null,
+  );
+  const firstWithKey = new Map<string, number>();
+  rows.forEach((row, index) => {
+    const key = row?.key;
+    if (typeof key === "string" && key && !firstWithKey.has(key))
+      firstWithKey.set(key, index);
+  });
+  rows.forEach((row, index) => {
+    if (!row) return;
+    const step = index + 1;
+    const fail: Fail = (message, field) =>
+      errors.push({ step, ...(field ? { field } : {}), message });
+    const branch = BRANCH_NAMES[String(row.type)];
+    const label = branch ? `Step ${step} (${branch.name})` : `Step ${step}`;
+    const key = typeof row.key === "string" ? row.key : undefined;
+    if (key === WORKFLOW_END)
+      fail(
+        `${label}: "key" can't be "${WORKFLOW_END}", because "${WORKFLOW_END}" marks where a path stops.`,
+        "key",
+      );
+    else if (key && firstWithKey.get(key) !== index)
+      fail(
+        `Steps ${(firstWithKey.get(key) ?? 0) + 1} and ${step} share the key "${key}". Give each step its own key.`,
+        "key",
+      );
+    if (branch) {
+      for (const [field, exit] of [
+        ["yesNext", branch.yes],
+        ["noNext", branch.no],
+      ] as const)
+        if (row[field] === undefined)
+          fail(
+            `${label} needs "${field}", where the "${exit}" path goes: another step's "key", or "${WORKFLOW_END}".`,
+            field,
+          );
+      if (row.next !== undefined)
+        fail(
+          `${label} continues on "yesNext" and "noNext", so it can't also have "next".`,
+          "next",
+        );
+    } else {
+      for (const field of ["yesNext", "noNext"] as const)
+        if (row[field] !== undefined)
+          fail(
+            `${label}: only condition and wait_for_connection steps branch, so "${field}" doesn't apply. Give it a single "next".`,
+            field,
+          );
+    }
+    const exits = branch
+      ? (["yesNext", "noNext"] as const)
+      : (["next"] as const);
+    for (const field of exits) {
+      const target = row[field];
+      if (typeof target !== "string" || !target || target === WORKFLOW_END)
+        continue;
+      if (target === key)
+        fail(`${label}: "${field}" points back at the step itself.`, field);
+      else if (!firstWithKey.has(target))
+        fail(
+          `${label}: "${field}" points at "${target}", which is not the "key" of any step. Use another step's "key", or "${WORKFLOW_END}" to stop there.`,
+          field,
+        );
+    }
+  });
+}
+
 function stepRow(
   value: unknown,
   label: string,
@@ -408,9 +734,12 @@ export function checkCampaignSteps(
       step: 0,
       message: `A campaign can have at most ${MAX_CAMPAIGN_STEPS} steps (got ${steps.length}).`,
     });
+  const shaped = steps.some(hasWorkflowShape);
+  const workflow = options.workflow ?? shaped;
   let emailSeen = false;
   let connectSeen = false;
   const waitingMessages: number[] = [];
+  const unwaitedMessages: number[] = [];
   steps.forEach((value, index) => {
     const step = index + 1;
     const label = `Step ${step}`;
@@ -432,7 +761,19 @@ export function checkCampaignSteps(
 
     if (stepType === "email") {
       const reply = row.emailReplyToPrevious === true;
-      if (reply && !emailSeen)
+      if (
+        reply &&
+        workflow &&
+        !steps.some(
+          (other, at) =>
+            at !== index && (other as { type?: unknown })?.type === "email",
+        )
+      )
+        fail(
+          `${label}: "emailReplyToPrevious" needs an email step before it on every path, and this workflow has no other email. Give this email its own "emailSubject".`,
+          "emailReplyToPrevious",
+        );
+      else if (reply && !emailSeen && !workflow)
         fail(
           `${label}: "emailReplyToPrevious" needs an earlier email step to reply to, so the first email would lose it. Give this email its own "emailSubject".`,
           "emailReplyToPrevious",
@@ -468,29 +809,47 @@ export function checkCampaignSteps(
 
     if (stepType === "linkedin_message") {
       checkMessageBody(trimmedText(row.linkedinMessageBody), label, fail);
+      // A workflow waits for the accept with its own wait_for_connection step.
+      const waitsByDefault = connectSeen && !workflow;
       const mode =
         row.linkedinMessageMode ??
-        (connectSeen ? "wait_until_connected" : "skip_if_not_connected");
+        (waitsByDefault ? "wait_until_connected" : "skip_if_not_connected");
       const timeout = row.connectionTimeoutHours;
       if (timeout !== undefined) {
         if (mode !== "wait_until_connected")
           fail(
-            `${label}: "connectionTimeoutHours" only applies with "linkedinMessageMode": "wait_until_connected"${connectSeen ? "" : " (the default only after a linkedin_connection step)"}, so it would be dropped.`,
+            `${label}: "connectionTimeoutHours" only applies with "linkedinMessageMode": "wait_until_connected"${waitsByDefault ? "" : workflow ? " (in a workflow, a wait_for_connection step waits for the accept instead)" : " (the default only after a linkedin_connection step)"}, so it would be dropped.`,
             "connectionTimeoutHours",
           );
         else checkTimeoutRange(timeout, label, fail);
       }
       if (
-        connectSeen &&
+        waitsByDefault &&
         mode === "wait_until_connected" &&
         (timeout ?? DEFAULT_CONNECTION_WAIT_HOURS) ===
           DEFAULT_CONNECTION_WAIT_HOURS
       )
         waitingMessages.push(step);
+      if (
+        workflow &&
+        !shaped &&
+        connectSeen &&
+        row.linkedinMessageMode === undefined
+      )
+        unwaitedMessages.push(step);
     }
 
+    if (stepType === "condition") checkCondition(row, label, fail);
+    if (stepType === "wait_for_connection")
+      checkAcceptanceWait(row.connectionTimeoutHours, label, fail);
+
     checkTemplateTokens(row, label, fail, options);
   });
+  if (workflow) checkWorkflowPaths(steps, errors);
+  if (unwaitedMessages.length > 0)
+    warnings.push(
+      `${listSteps(unwaitedMessages)} ${unwaitedMessages.length === 1 ? "is a LinkedIn message" : "are LinkedIn messages"} after the connection request, and this campaign is a workflow, so ${unwaitedMessages.length === 1 ? "it doesn't" : "they don't"} wait for the accept: anyone who hasn't accepted by then is skipped. To wait, edit the workflow dench campaign steps get <campaign> prints, or add a wait_for_connection step after the request with "yesNext" leading to the message. To skip on purpose, set "linkedinMessageMode": "skip_if_not_connected".`,
+    );
   if (waitingMessages.length >= 2)
     warnings.push(
       `${listSteps(waitingMessages)} are LinkedIn messages after the connection request. Each waits up to ${DEFAULT_CONNECTION_WAIT_HOURS / 24} days for the accept by default, so someone who never accepts holds the sequence for up to ${(waitingMessages.length * DEFAULT_CONNECTION_WAIT_HOURS) / 24} days. Give the later ones "linkedinMessageMode": "skip_if_not_connected" or a shorter "connectionTimeoutHours".`,
@@ -552,6 +911,8 @@ export function checkStepEdits(
           );
       }
     }
+    if (stepType === "wait_for_connection")
+      checkAcceptanceWait(row.connectionTimeoutHours, label, fail);
     checkTemplateTokens(row, label, fail, options);
   });
   return { errors, warnings: [] };
@@ -564,8 +925,12 @@ const KEEP_WHEN_OMITTED = [
   "connectionTimeoutHours",
   "likeReaction",
   "likeMaxPostAgeDays",
+  "likeSkipPreviousWait",
   "likeSkipNextWait",
+  "likeCount",
   "withdrawAfterHours",
+  ...FROZEN_AFTER_LAUNCH,
+  "conditionValue",
 ] as const;
 
 const CLEARED_VALUES: Record<string, unknown> = {
@@ -587,8 +952,63 @@ const TYPE_NAMES: Record<StepType, string> = {
   linkedin_message: "a LinkedIn message",
   linkedin_like_post: "a post reaction",
   linkedin_inmail: "an InMail",
+  condition: "an If / else",
+  wait_for_connection: "a Wait for them to accept",
+};
+
+const STEP_NAMES: Record<string, string> = {
+  condition: "If / else",
+  wait_for_connection: "Wait for them to accept",
 };
 
+/** Why a launched campaign's file can't change these paths and checks. */
+function frozenFieldProblems(
+  stored: readonly StoredStep[],
+  edits: ReadonlyMap<number, Record<string, unknown>>,
+  campaign: string,
+): string[] {
+  const problems: string[] = [];
+  let paths = false;
+  let checks = false;
+  for (const [index, fields] of [...edits.entries()].sort(
+    ([a], [b]) => a - b,
+  )) {
+    const before = stepToInput(stored[index]);
+    const changed = FROZEN_AFTER_LAUNCH.filter(
+      (field) => fields[field] !== undefined && fields[field] !== before[field],
+    );
+    if (!changed.length) continue;
+    const name = STEP_NAMES[stored[index].type];
+    const label = `Step ${index + 1}${name ? ` (${name})` : ""}`;
+    const list = changed.map((field) => `"${field}"`).join(", ");
+    const isPath = (field: string) =>
+      (PATH_KEYS as readonly string[]).includes(field);
+    if (changed.some(isPath)) paths = true;
+    if (!changed.every(isPath)) checks = true;
+    problems.push(
+      `${label}: ${list} can't change after launch (the file has ${changed
+        .map(
+          (field) =>
+            `${field} ${JSON.stringify(fields[field])} instead of ${JSON.stringify(before[field] ?? null)}`,
+        )
+        .join(", ")}).`,
+    );
+  }
+  if (!problems.length) return problems;
+  const why = [
+    paths
+      ? "Where a launched campaign's steps lead stays fixed, because people may already be on those paths."
+      : "",
+    checks
+      ? 'A launched If / else keeps what it checks; you can still change its "conditionValue".'
+      : "",
+  ].filter(Boolean);
+  return [
+    ...problems,
+    `${why.join(" ")} Nothing was saved. To change it, copy the campaign with dench campaign duplicate ${campaign} and set the copy's steps.`,
+  ];
+}
+
 export class StepEditError extends Error {}
 
 export type StoredStep = Record<string, unknown> & { type: string };
@@ -607,6 +1027,27 @@ export type StepEditOptions = StepCheckOptions & {
   draft?: boolean;
 };
 
+/**
+ * Where each file row's `key` sits among the stored steps: null when some row
+ * has no key or two rows share one (match by order instead), undefined when
+ * every row has its own key but one names no stored step.
+ */
+function keyMatch(
+  stored: readonly StoredStep[],
+  rows: readonly Record<string, unknown>[],
+): number[] | null | undefined {
+  const keys = rows.map((row) => row.key);
+  if (
+    keys.some((key) => typeof key !== "string" || !key) ||
+    new Set(keys).size !== keys.length
+  )
+    return null;
+  const indexes = keys.map((key) =>
+    stored.findIndex((step) => step.key === key),
+  );
+  return indexes.includes(-1) ? undefined : indexes;
+}
+
 export function planStepEdits(
   storedSteps: readonly StoredStep[],
   entries: readonly unknown[],
@@ -632,14 +1073,24 @@ export function planStepEdits(
   const byId = withIds > 0;
   if (!byId && rows.length !== stored.length)
     throw new StepEditError(
-      `The file has ${rows.length} ${rows.length === 1 ? "step" : "steps"} and the campaign has ${stored.length}. steps edit changes steps in place, matched by order, so it needs all ${stored.length}; to edit only some, include "stepId" from dench campaign steps get ${campaign} --with-ids.`,
+      `The file has ${rows.length} ${rows.length === 1 ? "step" : "steps"} and the campaign has ${stored.length}. steps edit changes steps in place, matched by ${options.workflow ? '"key" or by order' : "order"}, so it needs all ${stored.length}; to edit only some, include "stepId" from dench campaign steps get ${campaign} --with-ids.`,
     );
+  // A workflow is stored in path order, which can differ from the file's,
+  // so its steps match by key whenever every key names a stored step.
+  const keyIndex = byId || !options.workflow ? null : keyMatch(stored, rows);
+  if (keyIndex === undefined && !options.draft) {
+    const keys = new Set(stored.map((step) => step.key));
+    const unknown = rows.findIndex((row) => !keys.has(row.key));
+    throw new StepEditError(
+      `Step ${unknown + 1} in the file has "key": ${JSON.stringify(rows[unknown].key)}, which is not a step of this campaign. After launch every step keeps its "key"; use the keys dench campaign steps get ${campaign} prints.`,
+    );
+  }
   const restructure = options.draft
     ? `To add, remove, reorder or retype steps on a draft, use dench campaign steps set ${campaign} --file steps.json.`
     : `After launch a step keeps its type and place; to change the sequence, copy it with dench campaign duplicate ${campaign} and set the copy's steps.`;
   const edits = new Map<number, Record<string, unknown>>();
   rows.forEach((row, position) => {
-    let index = position;
+    let index = keyIndex?.[position] ?? position;
     if (byId) {
       index = stored.findIndex(
         (step) => String(step._id) === String(row.stepId),
@@ -665,6 +1116,10 @@ export function planStepEdits(
     const { stepId: _stepId, updatedAt: _updatedAt, ...fields } = row;
     edits.set(index, fields);
   });
+  if (!options.draft) {
+    const frozen = frozenFieldProblems(stored, edits, campaign);
+    if (frozen.length) throw new StepEditError(frozen.join("\n"));
+  }
 
   const warnings: string[] = [];
   const steps = stored.map((step, index) => {
@@ -674,9 +1129,16 @@ export function planStepEdits(
     const after: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(fields))
       if (value !== undefined) after[key] = value;
+    const kept: string[] = [];
     for (const key of KEEP_WHEN_OMITTED)
-      if (after[key] === undefined && before[key] !== undefined)
+      if (after[key] === undefined && before[key] !== undefined) {
         after[key] = before[key];
+        kept.push(key);
+      }
+    // A new check or comparison leaves behind the saved settings it ignores.
+    if (step.type === "condition")
+      for (const key of conditionDrops(after))
+        if (kept.includes(key)) delete after[key];
     if (
       hasHtmlAndTextBody(before) &&
       trimmedText(after.emailTextBody) !== "" &&