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

package/campaign.ts

@@ -31,14 +31,18 @@ import {
 import {
   checkCampaignSteps,
   hasHtmlAndTextBody,
+  hasWorkflowShape,
+  isBranchStep,
   planStepEdits,
   STEP_TYPES,
   StepEditError,
   staleHtmlSteps,
   staleHtmlWarning,
   stepToInput,
+  WORKFLOW_END,
 } from "./lib/campaign-steps";
 import {
+  branchExitLabel,
   personAddress,
   type TimelineResult,
   timelineSteps,
@@ -109,6 +113,7 @@ export type CampaignRow = {
   sendSchedules?: SendSchedule[];
   dailySendCap?: number;
   stepCount?: number;
+  stepModel?: string;
   totalEnrolled?: number;
   activeCount?: number;
   pausedCount?: number;
@@ -147,6 +152,8 @@ type CurrentRun = {
   type?: string;
   stepIndex?: number;
   waitUntil?: number;
+  /** A wait for acceptance: when it stops waiting either way. */
+  timeoutAt?: number;
   retryAt?: number;
   lastError?: string;
   hold?: LinkedinHold;
@@ -189,6 +196,8 @@ type CampaignAnalytics = {
   clicked?: number;
   linkedinSent?: number;
   replyRate?: number;
+  /** Workflow branch steps: how many people took each exit. */
+  branchStats?: Array<{ stepId: string; yes: number; no: number }>;
   truncated?: boolean;
 };
 
@@ -211,6 +220,10 @@ type CampaignLive = {
     personName: string | null;
     at: number;
     hold: LinkedinHold | null;
+    /** Waiting for them to accept: when the wait ends either way. */
+    acceptanceDeadline?: number;
+    /** An If / else: what it checks, e.g. "Has an email address". */
+    label?: string;
   } | null;
   paused: {
     reason: string;
@@ -617,28 +630,72 @@ export { STEP_TYPES };
 
 export type StepsFile = { steps: JsonRecord[]; warnings: string[] };
 
+export type StepModel = "linear" | "workflow";
+
+/**
+ * The model to save steps as: the file's `stepModel`, else a workflow when
+ * the campaign is one or the steps have keys, paths or logic steps.
+ * Undefined leaves a linear campaign linear.
+ */
+function stepModelFor(
+  steps: readonly unknown[],
+  fileModel: unknown,
+  campaignModel: StepModel | undefined,
+  source: string,
+): StepModel | undefined {
+  if (
+    fileModel !== undefined &&
+    fileModel !== "linear" &&
+    fileModel !== "workflow"
+  ) {
+    throw new CampaignCliError(
+      `${source}: "stepModel" must be "workflow" or "linear".`,
+    );
+  }
+  if (campaignModel === "workflow" && fileModel === "linear") {
+    throw new CampaignCliError(
+      `This campaign is a workflow, so it can't go back to a plain list of steps. Leave "stepModel" out, or start a new campaign with dench campaign draft and set the steps there (dench campaign duplicate keeps the workflow).`,
+    );
+  }
+  const shaped = steps.findIndex(hasWorkflowShape);
+  if (fileModel === "linear" && shaped >= 0) {
+    throw new CampaignCliError(
+      `Step ${shaped + 1}: condition, wait_for_connection, "key", "next", "yesNext" and "noNext" only work in a workflow. Set "stepModel": "workflow" (or leave it out) to save these steps as one.`,
+    );
+  }
+  if (fileModel === "workflow" || campaignModel === "workflow" || shaped >= 0)
+    return "workflow";
+  return fileModel === "linear" ? "linear" : undefined;
+}
+
 /**
- * Parse a steps file: a JSON array of step objects (or `{ "steps": [...] }`).
+ * Parse a steps file: a JSON array of step objects (or `{ "steps": [...] }`,
+ * optionally with `"stepModel"`).
  * Checks the shape the server validates so a typo is caught here with a
  * step number instead of a Convex validator message.
  */
 export function readStepsJson(
   raw: string,
   source = "The steps file",
-  options: { allowSingleBraces?: boolean } = {},
-): StepsFile {
+  options: { allowSingleBraces?: boolean; stepModel?: StepModel } = {},
+): StepsFile & { stepModel?: StepModel } {
   let parsed: unknown;
   try {
     parsed = JSON.parse(raw);
   } catch {
     throw new CampaignCliError(`${source} is not valid JSON.`);
   }
+  const wrapped =
+    parsed &&
+    typeof parsed === "object" &&
+    !Array.isArray(parsed) &&
+    Array.isArray((parsed as JsonRecord).steps)
+      ? (parsed as JsonRecord)
+      : null;
   const steps = Array.isArray(parsed)
     ? parsed
-    : parsed &&
-        typeof parsed === "object" &&
-        Array.isArray((parsed as JsonRecord).steps)
-      ? ((parsed as JsonRecord).steps as unknown[])
+    : wrapped
+      ? (wrapped.steps as unknown[])
       : null;
   if (!steps) {
     throw new CampaignCliError(
@@ -648,22 +705,33 @@ export function readStepsJson(
   if (steps.length === 0) {
     throw new CampaignCliError(`${source} has no steps.`);
   }
+  const stepModel = stepModelFor(
+    steps,
+    wrapped?.stepModel,
+    options.stepModel,
+    source,
+  );
   const check = checkCampaignSteps(steps, {
     allowSingleBraces: options.allowSingleBraces,
     singleBraceOverride: "--allow-single-braces",
+    workflow: stepModel === "workflow",
   });
   if (check.errors.length > 0) {
     throw new CampaignCliError(
       check.errors.map((issue) => issue.message).join("\n"),
     );
   }
-  return { steps: steps as JsonRecord[], warnings: check.warnings };
+  return {
+    steps: steps as JsonRecord[],
+    warnings: check.warnings,
+    ...(stepModel ? { stepModel } : {}),
+  };
 }
 
 export function parseStepsJson(
   raw: string,
   source = "The steps file",
-  options: { allowSingleBraces?: boolean } = {},
+  options: { allowSingleBraces?: boolean; stepModel?: StepModel } = {},
 ): JsonRecord[] {
   return readStepsJson(raw, source, options).steps;
 }
@@ -989,16 +1057,84 @@ const STEP_LABELS: Record<string, string> = {
   linkedin_visit: "Visit profile",
   linkedin_like_post: "React to a post",
   linkedin_inmail: "LinkedIn InMail",
+  condition: "If / else",
+  wait_for_connection: "Wait for them to accept",
 };
 
-function stepLabel(step: { type: string; waitHours?: unknown }): string {
+type LabeledStep = { type: string; waitHours?: unknown; label?: unknown };
+
+/** A step's name; If / else steps use the server's label of what they check. */
+function stepLabel(step: LabeledStep): string {
   if (step.type === "wait") {
     const hours = typeof step.waitHours === "number" ? step.waitHours : 0;
     return `Wait ${fmtHours(hours)}`;
   }
+  if (isBranchStep(step.type) && typeof step.label === "string" && step.label)
+    return step.label;
   return STEP_LABELS[step.type] ?? step.type;
 }
 
+type WorkflowStep = LabeledStep & {
+  _id?: unknown;
+  key?: unknown;
+  next?: unknown;
+  yesNext?: unknown;
+  noNext?: unknown;
+  connectionTimeoutHours?: unknown;
+};
+
+/**
+ * One line per workflow step, numbered as stored: where each exit leads,
+ * shown only where it is not simply the following step.
+ */
+export function workflowStepLines(steps: readonly WorkflowStep[]): string[] {
+  const keyIndex = new Map<string, number>();
+  steps.forEach((step, index) => {
+    if (typeof step.key === "string" && !keyIndex.has(step.key))
+      keyIndex.set(step.key, index);
+  });
+  const target = (to: unknown): string => {
+    if (to === undefined || to === WORKFLOW_END) return "End";
+    const index = typeof to === "string" ? keyIndex.get(to) : undefined;
+    return index === undefined
+      ? `"${String(to)}" (not a step)`
+      : `${stepLabel(steps[index])} (step ${index + 1})`;
+  };
+  return steps.map((step, index) => {
+    let name = stepLabel(step);
+    if (
+      step.type === "wait_for_connection" &&
+      typeof step.connectionTimeoutHours === "number"
+    )
+      name += ` (up to ${fmtHours(step.connectionTimeoutHours)})`;
+    if (isBranchStep(step.type))
+      return `${index + 1}. ${name} → ${branchExitLabel(step.type, "yes")}: ${target(step.yesNext)} · ${branchExitLabel(step.type, "no")}: ${target(step.noNext)}`;
+    const next = step.next;
+    const plain =
+      next === undefined ||
+      (next === WORKFLOW_END
+        ? index === steps.length - 1
+        : keyIndex.get(String(next)) === index + 1);
+    return plain
+      ? `${index + 1}. ${name}`
+      : `${index + 1}. ${name} → ${target(next)}`;
+  });
+}
+
+function describeSteps(
+  steps: readonly WorkflowStep[],
+  workflow: boolean,
+): string[] {
+  if (!workflow)
+    return [
+      `Steps (${steps.length}): ${steps.map((step) => stepLabel(step)).join(" → ")}`,
+    ];
+  return [
+    `Steps (${steps.length}, a workflow with paths):`,
+    ...workflowStepLines(steps).map((line) => `  ${line}`),
+  ];
+}
+
 const HOLD_TEXT: Record<string, string> = {
   checking: "checking whether they are already connected",
   spacing: "spacing out sends so they look human",
@@ -1046,6 +1182,7 @@ const NEXT_VERBS: Record<string, string> = {
   withdraw: "Withdraw the pending invitation for",
   email: "Send an email to",
   wait: "Wait for",
+  check: "Run an If / else check for",
 };
 
 const TOUCH_LABELS: Record<string, string> = {
@@ -1056,6 +1193,8 @@ const TOUCH_LABELS: Record<string, string> = {
   linkedin_like_post: "post reaction sent",
   linkedin_inmail: "InMail sent",
   wait: "wait finished",
+  condition: "If / else checked",
+  wait_for_connection: "acceptance wait finished",
 };
 
 const RUN_STATUS_TEXT: Record<string, string> = {
@@ -1100,10 +1239,31 @@ function describePerson(
   const hold = describeHold(run?.hold);
   const bits: string[] = [enrollment.status];
   if (run?.status && enrollment.status === "active") {
-    const runText = RUN_STATUS_TEXT[run.status] ?? run.status;
-    const stepText = run.type ? (STEP_LABELS[run.type] ?? run.type) : "step";
-    bits.push(`${runText}: ${stepText.toLowerCase()}`);
-    if (run.status === "waiting" && run.waitUntil) {
+    // An If / else or acceptance check reads the profile; it sends nothing.
+    const runText =
+      isBranchStep(run.type) &&
+      (run.status === "queued" || run.status === "running")
+        ? "checking"
+        : (RUN_STATUS_TEXT[run.status] ?? run.status);
+    const stepDoc =
+      typeof run.stepIndex === "number"
+        ? detail.steps.find((step) => step.order === run.stepIndex)
+        : undefined;
+    const stepText = run.type
+      ? isBranchStep(run.type) && stepDoc?.type === run.type
+        ? stepLabel(stepDoc)
+        : (STEP_LABELS[run.type] ?? run.type)
+      : "step";
+    bits.push(
+      `${runText}: ${isBranchStep(run.type) ? stepText : stepText.toLowerCase()}`,
+    );
+    if (
+      run.type === "wait_for_connection" &&
+      run.status === "waiting" &&
+      run.timeoutAt
+    ) {
+      bits.push(`stops waiting ${fmtWhenRelative(run.timeoutAt)}`);
+    } else if (run.status === "waiting" && run.waitUntil) {
       bits.push(`until ${fmtWhenRelative(run.waitUntil)}`);
     } else if (run.status === "retry" && run.retryAt) {
       bits.push(`retry ${fmtRelative(run.retryAt)}`);
@@ -1130,6 +1290,9 @@ function describePerson(
             status: run.status,
             type: run.type,
             waitUntil: run.waitUntil,
+            ...(run.timeoutAt !== undefined
+              ? { timeoutAt: run.timeoutAt }
+              : {}),
             retryAt: run.retryAt,
             lastError: run.lastError,
           }
@@ -1360,11 +1523,12 @@ async function runGet(ctx: CampaignCliContext): Promise<void> {
   const steps = [...detail.steps].sort(
     (a, b) => (a.order ?? 0) - (b.order ?? 0),
   );
-  lines.push(
-    steps.length === 0
-      ? "Steps: none yet — dench campaign steps set <campaign> --file steps.json"
-      : `Steps (${steps.length}): ${steps.map((step) => stepLabel(step)).join(" → ")}`,
-  );
+  const workflow = sequence.stepModel === "workflow";
+  if (steps.length === 0)
+    lines.push(
+      "Steps: none yet — dench campaign steps set <campaign> --file steps.json",
+    );
+  else lines.push(...describeSteps(steps, workflow));
   if (sequence.lastError) lines.push(`Last error: ${sequence.lastError}`);
 
   lines.push("", "Funnel");
@@ -1396,6 +1560,7 @@ async function runGet(ctx: CampaignCliContext): Promise<void> {
   lines.push(
     `  Done        finished ${a.finished ?? 0} · stopped ${a.stopped ?? 0} · failed ${a.failed ?? 0}`,
   );
+  lines.push(...branchStatLines(steps, a.branchStats));
   if (a.truncated) {
     lines.push(
       "  (counts are approximate — this campaign has more history than one read can hold)",
@@ -1410,13 +1575,8 @@ async function runGet(ctx: CampaignCliContext): Promise<void> {
   } else if (sequence.status === "active") {
     lines.push("  Now:  nothing is being sent right now");
   }
-  if (live?.next) {
-    const who = live.next.personName ? ` ${live.next.personName}` : "";
-    const hold = describeHold(live.next.hold);
-    lines.push(
-      `  Next: ${NEXT_VERBS[live.next.kind] ?? live.next.kind}${who} at ${fmtWhenRelative(live.next.at)}${hold ? ` — on hold: ${hold}` : ""}`,
-    );
-  } else if (sequence.status === "active") {
+  if (live?.next) lines.push(`  Next: ${describeNext(live.next)}`);
+  else if (sequence.status === "active") {
     lines.push(
       "  Next: nothing scheduled — everyone is finished, waiting on a reply, or stopped",
     );
@@ -1476,6 +1636,34 @@ async function runGet(ctx: CampaignCliContext): Promise<void> {
   );
 }
 
+/** How many people took each exit of the workflow's branch steps. */
+function branchStatLines(
+  steps: readonly WorkflowStep[],
+  stats: CampaignAnalytics["branchStats"],
+): string[] {
+  const lines: string[] = [];
+  for (const stat of stats ?? []) {
+    const index = steps.findIndex((step) => String(step._id) === stat.stepId);
+    if (index < 0) continue;
+    const step = steps[index];
+    lines.push(
+      `${lines.length ? "             " : "  Paths      "} step ${index + 1} ${stepLabel(step)} → ${branchExitLabel(step.type, "yes")} ${stat.yes} · ${branchExitLabel(step.type, "no")} ${stat.no}`,
+    );
+  }
+  return lines;
+}
+
+export function describeNext(next: NonNullable<CampaignLive["next"]>): string {
+  const hold = describeHold(next.hold);
+  const held = hold ? ` — on hold: ${hold}` : "";
+  if (typeof next.acceptanceDeadline === "number")
+    return `Wait for ${next.personName ?? "them"} to accept the connection request — next check ${fmtWhenRelative(next.at)}, stops waiting ${fmtWhenRelative(next.acceptanceDeadline)}${held}`;
+  const who = next.personName ? ` ${next.personName}` : "";
+  if (next.kind === "check" && next.label)
+    return `Check "${next.label}" for${who || " the next person"} at ${fmtWhenRelative(next.at)}${held}`;
+  return `${NEXT_VERBS[next.kind] ?? next.kind}${who} at ${fmtWhenRelative(next.at)}${held}`;
+}
+
 async function runSet(ctx: CampaignCliContext): Promise<void> {
   const name = valueFlag(ctx.args, "--name")?.trim();
   if (name === "") {
@@ -1571,7 +1759,12 @@ async function runSteps(ctx: CampaignCliContext): Promise<void> {
             }
           : stepToInput(step),
       );
-    console.log(JSON.stringify(steps, null, 2));
+    // A workflow says so, so the file saves back as one even without paths.
+    const printed =
+      detail.sequence.stepModel === "workflow"
+        ? { stepModel: "workflow", steps }
+        : steps;
+    console.log(JSON.stringify(printed, null, 2));
     return;
   }
   if (!file) {
@@ -1588,7 +1781,10 @@ async function runSteps(ctx: CampaignCliContext): Promise<void> {
   const raw = await readFile(file, "utf8").catch(() => {
     throw new CampaignCliError(`Cannot read ${file}`);
   });
-  const { steps, warnings } = readStepsJson(raw, file, { allowSingleBraces });
+  const { steps, warnings, stepModel } = readStepsJson(raw, file, {
+    allowSingleBraces,
+    stepModel: row.stepModel === "workflow" ? "workflow" : undefined,
+  });
   if (steps.some(hasHtmlAndTextBody)) {
     const stored = (await loadDetail(ctx, String(row._id))).steps;
     for (const index of staleHtmlSteps(steps, stored)) {
@@ -1599,13 +1795,36 @@ async function runSteps(ctx: CampaignCliContext): Promise<void> {
   const result = (await callMutation(ctx, `${OUTREACH}:replaceSteps`, {
     sequenceId: row._id,
     steps,
+    ...(stepModel ? { stepModel } : {}),
   })) as { ok: true; stepCount: number };
-  out(ctx, { ...result, sequenceId: row._id, steps, warnings }, [
-    `Saved ${result.stepCount} steps on "${row.name}": ${steps
-      .map((step) => stepLabel(step as { type: string; waitHours?: unknown }))
-      .join(" → ")}`,
-    ...warnings.map((warning) => `Warning: ${warning}`),
-  ]);
+  const workflow = stepModel === "workflow";
+  // A workflow is stored in path order, which can differ from the file's.
+  const saved = workflow
+    ? sortedSteps(await loadDetail(ctx, String(row._id)))
+    : (steps as WorkflowStep[]);
+  out(
+    ctx,
+    {
+      ...result,
+      sequenceId: row._id,
+      ...(stepModel ? { stepModel } : {}),
+      steps,
+      warnings,
+    },
+    [
+      workflow
+        ? `Saved ${result.stepCount} steps on "${row.name}" as a workflow:`
+        : `Saved ${result.stepCount} steps on "${row.name}": ${saved
+            .map((step) => stepLabel(step))
+            .join(" → ")}`,
+      ...(workflow ? workflowStepLines(saved).map((line) => `  ${line}`) : []),
+      ...warnings.map((warning) => `Warning: ${warning}`),
+    ],
+  );
+}
+
+function sortedSteps(detail: CampaignDetail): CampaignDetail["steps"] {
+  return [...detail.steps].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
 }
 
 function stepsInFile(parsed: unknown): unknown[] | null {
@@ -1646,6 +1865,7 @@ async function runStepsEdit(
     );
   }
   const detail = await loadDetail(ctx, String(row._id));
+  const workflow = detail.sequence.stepModel === "workflow";
   const status = detail.sequence.status ?? row.status;
   const draft = status === "draft";
   let plan: ReturnType<typeof planStepEdits>;
@@ -1655,6 +1875,7 @@ async function runStepsEdit(
       singleBraceOverride: "--allow-single-braces",
       campaign: String(row._id),
       draft,
+      ...(workflow ? { workflow } : {}),
     });
   } catch (error) {
     if (error instanceof StepEditError)
@@ -1683,6 +1904,9 @@ async function runStepsEdit(
     await callMutation(ctx, `${OUTREACH}:replaceSteps`, {
       sequenceId: row._id,
       steps: plan.steps,
+      ...(workflow || plan.steps.some(hasWorkflowShape)
+        ? { stepModel: "workflow" }
+        : {}),
     });
   } else {
     await callMutation(ctx, `${OUTREACH}:updateSteps`, {
@@ -1704,7 +1928,7 @@ async function runStepsEdit(
       `Updated ${plan.changes.length} of ${plan.steps.length} steps on "${row.name}"${draft ? "" : " for sends from now on; messages already sent are unchanged"}:`,
       ...plan.changes.map(
         (change) =>
-          `  Step ${change.step} (${stepLabel(plan.steps[change.step - 1] as { type: string; waitHours?: unknown })}): ${change.fields.join(", ")}`,
+          `  Step ${change.step} (${stepLabel(plan.steps[change.step - 1] as LabeledStep)}): ${change.fields.join(", ")}`,
       ),
       ...warningLines,
     ],
@@ -2035,6 +2259,13 @@ const STEP_BLOCKER_REASONS: Record<string, RegExp> = {
   email_sender_disconnected: /sender must be reconnected/i,
   linkedin_sender_disconnected: /sender must be reconnected/i,
   reply_without_prior_email: /replies to a previous email/i,
+  workflow_path_invalid:
+    /isn't a step in this campaign|goes back to|makes a loop|has nothing on its|can't also have a single next step|only If \/ else and Wait (?:until they|for them to) accept steps can branch|nobody will reach it|share the id|marks where a path stops|only work in a workflow campaign/i,
+  wait_for_connection_without_invite:
+    /without a LinkedIn connection request before it/i,
+  opened_check_without_email: /reaches it without an email/i,
+  open_tracking_unavailable: /opens aren't tracked/i,
+  condition_field_missing: /which your leads don't have/i,
 };
 
 function blockerReasons(
@@ -2042,7 +2273,11 @@ function blockerReasons(
   reasons: readonly string[],
 ): string[] {
   if (typeof group.stepIndex !== "number") return [];
-  const step = new RegExp(`\\bstep ${group.stepIndex + 1}\\b`, "i");
+  // "step 3", or one of a list: "Steps 1 and 3 share the id …".
+  const step = new RegExp(
+    `\\bsteps? (?:\\d+(?:, | and ))*${group.stepIndex + 1}\\b`,
+    "i",
+  );
   const forStep = reasons.filter((reason) => step.test(reason));
   const own = STEP_BLOCKER_REASONS[group.code];
   if (own) return forStep.filter((reason) => own.test(reason));
@@ -2060,6 +2295,14 @@ const STEPS_FIX = (id: string) => [
 ];
 
 const BLOCKER_FIXES: Record<string, (id: string) => string[]> = {
+  workflow_path_invalid: STEPS_FIX,
+  wait_for_connection_without_invite: STEPS_FIX,
+  opened_check_without_email: STEPS_FIX,
+  open_tracking_unavailable: STEPS_FIX,
+  condition_field_missing: (id) => [
+    "dench crm fields list lead",
+    ...STEPS_FIX(id),
+  ],
   no_steps: STEPS_FIX,
   too_many_steps: STEPS_FIX,
   step_invalid: STEPS_FIX,
@@ -2522,18 +2765,24 @@ async function runRemove(ctx: CampaignCliContext): Promise<void> {
 const PERSON_SET_USAGE =
   'dench campaign person set <campaign> --person <enrollmentId|name> [--email ada@new.com] [--linkedin-url https://linkedin.com/in/ada] [--field "Job Title=CTO" ...]';
 
+/** A field reference may be pasted directly from either merge-token syntax. */
+function unwrappedFieldReference(reference: string): string {
+  const value = reference.trim();
+  if (
+    (value.startsWith("{{") && value.endsWith("}}")) ||
+    (value.startsWith("[[") && value.endsWith("]]"))
+  ) {
+    return value.slice(2, -2).trim();
+  }
+  return value;
+}
+
 export function parseFieldFlags(
   values: readonly string[],
 ): Array<{ key: string; value: string }> {
   return values.map((raw) => {
     const at = raw.indexOf("=");
-    const key =
-      at === -1
-        ? ""
-        : raw
-            .slice(0, at)
-            .trim()
-            .replace(/^\{\{\s*|\s*\}\}$/g, "");
+    const key = at === -1 ? "" : unwrappedFieldReference(raw.slice(0, at));
     const value = at === -1 ? "" : raw.slice(at + 1).trim();
     if (!key || !value) {
       throw new CampaignCliError(
@@ -2676,8 +2925,12 @@ async function runPersonShow(ctx: CampaignCliContext): Promise<void> {
     const doc = stepDocs.get(step.stepId);
     const label = stepLabel(doc ?? { type: step.type });
     const when = step.at === null ? "" : ` · ${fmtRelative(step.at)}`;
+    const until =
+      step.acceptanceDeadline !== undefined
+        ? ` · stops waiting ${fmtWhenRelative(step.acceptanceDeadline)}`
+        : "";
     lines.push(
-      `  Step ${step.step} · ${label} · ${[step.outcome, ...step.detail].join(" · ")}${when}`,
+      `  Step ${step.step} · ${label} · ${[step.outcome, ...step.detail].join(" · ")}${when}${until}`,
     );
     if (step.subject) lines.push(`      Subject: ${step.subject}`);
     if (step.text) {
@@ -2828,7 +3081,7 @@ function resolveLineKey(
 ): string {
   const variables = template?.variables ?? [];
   if (!variables.length) throw noLines(row);
-  const wanted = normalizedLineKey(reference.replace(/^\{\{\s*|\s*\}\}$/g, ""));
+  const wanted = normalizedLineKey(unwrappedFieldReference(reference));
   const match = variables.find(
     (variable) =>
       normalizedLineKey(variable.key) === wanted ||
@@ -3322,7 +3575,7 @@ async function runPreview(ctx: CampaignCliContext): Promise<void> {
   );
   const sendable = steps
     .map((step, index) => ({ step, number: index + 1 }))
-    .filter(({ step }) => step.type !== "wait");
+    .filter(({ step }) => step.type !== "wait" && !isBranchStep(step.type));
   if (!sendable.length) {
     throw new CampaignCliError(
       `"${row.name}" has no email or LinkedIn steps to preview yet. Add them: dench campaign steps set ${row._id} --file steps.json`,
@@ -3338,8 +3591,9 @@ async function runPreview(ctx: CampaignCliContext): Promise<void> {
     }
     chosen = sendable.filter((entry) => entry.number === number);
     if (!chosen.length) {
+      const kind = steps[number - 1]?.type;
       throw new CampaignCliError(
-        `Step ${number} is a wait, so it sends nothing. Steps with a message: ${sendable.map((entry) => entry.number).join(", ")}.`,
+        `Step ${number} is ${kind === "condition" ? "an If / else" : kind === "wait_for_connection" ? "a Wait for them to accept" : "a wait"}, so it sends nothing. Steps with a message: ${sendable.map((entry) => entry.number).join(", ")}.`,
       );
     }
   }
@@ -3364,8 +3618,13 @@ async function runPreview(ctx: CampaignCliContext): Promise<void> {
       })) as MessagePreview,
     })),
   );
+  const firstPerson = personRef
+    ? ""
+    : " (the first person; pick someone with --person)";
   const lines = [
-    `What ${name} gets from "${row.name}"${personRef ? "" : " (the first person; pick someone with --person)"}:`,
+    detail.sequence.stepModel === "workflow"
+      ? `The messages on every path of "${row.name}", for ${name}${firstPerson}. They get only the ones on the path they take:`
+      : `What ${name} gets from "${row.name}"${firstPerson}:`,
   ];
   for (const { step, number, preview } of rendered)
     lines.push("", ...previewLines(number, step, preview));
@@ -3959,7 +4218,7 @@ export function campaignHelp(subcommand?: string): void {
   );
 }
 
-function campaignHelpText(): string {
+export function campaignHelpText(): string {
   return `Usage: dench campaign <subcommand> [--json]
 
 Outreach campaigns send email and LinkedIn steps to a list of people on one
@@ -4002,12 +4261,16 @@ Create and configure:
   dench campaign duplicate <campaign> [--name "Founder outreach 2"]   # new draft: same steps, schedule, senders and lines, no people
       Over ${MAX_CAMPAIGN_PEOPLE} people: duplicate, then add the next page of the search (--page-token) to the copy.
   dench campaign steps get <campaign> [--with-ids]  # prints steps as JSON you can edit; --with-ids adds stepId and updatedAt
+      A workflow prints {"stepModel":"workflow","steps":[...]} with each step's key and paths; steps set takes it back as is.
   dench campaign steps set <campaign> --file steps.json [--allow-single-braces]   # replaces every step; drafts only
   dench campaign steps edit <campaign> --file steps.json [--allow-single-braces]  # changes text and waits in place, also after launch
       Keeps the number, order and type of every step. Each step in the file is its full new content: leaving out a
-      subject, body, note, onlyIf or emailReplyToPrevious clears it (senders and LinkedIn wait settings are kept).
-      Steps match by order, or by stepId from steps get --with-ids to edit only some; a step saved since you read it
-      is refused, not overwritten. Messages already sent, or already being prepared, keep their text.
+      subject, body, note, onlyIf or emailReplyToPrevious clears it (senders, LinkedIn wait settings, workflow
+      paths and If / else settings are kept). Steps match by order (a workflow's by key, in any order), or by
+      stepId from steps get --with-ids to edit only some; a step saved since you read it is refused, not
+      overwritten. Messages already sent, or already being prepared, keep their text. After launch a workflow's
+      paths (key, next, yesNext, noNext) and what an If / else checks (check, conditionField, conditionOperator)
+      stay fixed; conditionValue can change.
 
 Fill it:
   dench campaign draft [--name "New campaign"] [--request-id <8-64 char stable id>] [--timezone <tz>] \\
@@ -4110,11 +4373,29 @@ Send window spec (--window, repeatable, all in --timezone):
 of that day in the campaign's timezone; add a time and offset to be exact.
 
 steps.json: a JSON array of steps, in order. Types: email, wait, linkedin_visit,
-linkedin_connection, linkedin_message, linkedin_like_post, linkedin_inmail.
+linkedin_connection, linkedin_message, linkedin_like_post, linkedin_inmail,
+condition (If / else) and wait_for_connection (Wait for them to accept).
 See references/CAMPAIGNS.md for every field.
+Workflows (branching paths): give steps a "key" and say where each goes. A
+condition or wait_for_connection step needs "yesNext" and "noNext" (Yes / No, or
+Accepted / Not accepted); any other step may have "next" (default: the step after
+it). Each points at another step's "key", or "end" to stop there. condition needs
+"check": linkedin_connected, has_email, opened_last_email or field_value (with
+"conditionField", "conditionOperator" is|is_not|contains|is_empty|is_not_empty and,
+except for the empty checks, "conditionValue"). wait_for_connection waits
+connectionTimeoutHours = 24-2160 (1-90 days, default 720) and needs a
+linkedin_connection before it on every path. Steps with keys, paths or these
+types save the campaign as a workflow ("stepModel": "workflow"); a workflow
+stays one, and in a workflow a LinkedIn message does not wait for the accept on
+its own. steps set checks keys and paths before saving; the rest (every step
+reachable, paths only moving forward) is checked when it saves.
 Post reactions: likeReaction = like|celebrate|support|love|insightful|funny
-(default like); likeMaxPostAgeDays = 1-365 (default 30); likeSkipNextWait = true
-by default, skipping consecutive following waits when the reaction is skipped.
+(default like); likeMaxPostAgeDays = 1-365 (default 30); likeCount = 1-3 recent
+posts (default 1). likeSkipPreviousWait = true checks for eligible posts before
+the immediately preceding wait starts; no eligible posts skips that wait and
+the like while keeping following waits (omitted defaults false).
+likeSkipNextWait = true by default, skipping consecutive following waits when
+the reaction itself is skipped. Set false to keep those waits.
 InMail: linkedinMessageBody required (1-1900 chars), inmailSubject optional
 (up to 200 chars). Connected people skip InMail automatically; do not set onlyIf.
 Connection requests: withdrawAfterHours = 168-2160 (7-90 days); omitted or null