@dench.com/cli 3.5.6-staging.344 → 3.6.0-staging.356

package/campaign.ts

@@ -2,11 +2,11 @@
  * `dench campaign <subcommand>` — outreach campaigns (email + LinkedIn steps
  * on one schedule) from the terminal, and therefore from chat.
  *
- * Every subcommand talks straight to `functions/outreachSequences:*` over the
- * Convex HTTP client; there is no campaign-specific HTTP route. `dench email
- * multichannel` drives the same rows and keeps working — this namespace is
- * the fuller surface (schedule, steps round-trip, fill from a CRM view, the
- * Now/Next feed, per-person controls, the activity log).
+ * Most subcommands call the outreach functions through the authenticated
+ * client; the signal builder calls `/api/v1/campaigns/builder/*` over HTTP.
+ * `dench email multichannel` drives the same rows and keeps working — this
+ * namespace is the fuller surface (search and add people, schedule, steps
+ * round-trip, the Now/Next feed, per-person controls, the activity log).
  *
  * `<campaign>` is an id or an exact, case-insensitive name. A name shared by
  * several live campaigns is an error that lists the ids.
@@ -20,6 +20,29 @@ import { readFile } from "node:fs/promises";
 import type { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 import { collectPaginated } from "./email";
+import { usesSearchFlags } from "./lib/campaign-filters";
+import {
+  LINE_CENTS_PER_PERSON,
+  LinesFileError,
+  type LineTemplate,
+  linesTemplateFromFile,
+  normalizedLineKey,
+} from "./lib/campaign-lines";
+import {
+  checkCampaignSteps,
+  hasHtmlAndTextBody,
+  planStepEdits,
+  STEP_TYPES,
+  StepEditError,
+  staleHtmlSteps,
+  staleHtmlWarning,
+  stepToInput,
+} from "./lib/campaign-steps";
+import {
+  personAddress,
+  type TimelineResult,
+  timelineSteps,
+} from "./lib/campaign-timeline";
 import {
   assertNoUnknownFlags,
   CliArgError,
@@ -27,9 +50,18 @@ import {
   hasFlag,
   shift as shiftRaw,
 } from "./lib/cli-args";
+import { cliVersion } from "./lib/cli-version";
+import { formatCents } from "./lib/search-pricing";
 
 export class CampaignCliError extends Error {}
 
+export function unknownSubcommandMessage(
+  subcommand: string,
+  version: string,
+): string {
+  return `Unknown campaign subcommand: ${subcommand}. Run 'dench campaign help'. This is dench ${version}; a newer CLI may have it. Update with 'npm install -g @dench.com/cli@latest' or run 'npx -y -p @dench.com/cli@latest dench campaign ${subcommand} ...'.`;
+}
+
 type JsonRecord = Record<string, unknown>;
 
 type CampaignCliContext = {
@@ -37,6 +69,7 @@ type CampaignCliContext = {
   args: string[];
   jsonOutput: boolean;
   sessionToken?: string;
+  host?: string;
 };
 
 const OUTREACH = "functions/outreachSequences";
@@ -49,7 +82,6 @@ export const MAX_CAMPAIGN_PEOPLE = 300;
 /** Page size used when reading a CRM view; 100 keeps rows under the byte budget. */
 export const VIEW_PAGE_SIZE = 100;
 const MAX_VIEW_PAGES = 50;
-const MAX_STEPS = 20;
 const PEOPLE_PREVIEW_LIMIT = 50;
 const DEFAULT_EVENTS_PAGE_SIZE = 50;
 const MAX_EVENTS_PAGE_SIZE = 200;
@@ -90,6 +122,7 @@ export type CampaignRow = {
   ownerName?: string;
   isOwner?: boolean;
   createdAt?: number;
+  personalizationTemplate?: { variables?: Array<{ key: string }> };
 };
 
 type Enrollment = {
@@ -100,9 +133,11 @@ type Enrollment = {
   nextRunAt?: number;
   lastError?: string;
   repliedAt?: number;
+  repliedChannel?: string;
   linkedinProfileUrl?: string;
   entryId?: string;
   leadEntryId?: string;
+  firstContactedAt?: number;
 };
 
 type LinkedinHold = { reason: string; until?: number };
@@ -205,13 +240,23 @@ type CampaignLive = {
 
 type LaunchBlockerGroup = {
   code: string;
+  scope?: string;
   title: string;
   hint?: string;
   stepIndex?: number;
-  people: Array<{ enrollmentId?: string; name: string }>;
+  people: Array<{
+    enrollmentId?: string;
+    name: string;
+    fields?: Array<{ key: string; label: string }>;
+  }>;
   count: number;
 };
 
+export type ExplainedBlocker = LaunchBlockerGroup & {
+  reasons: string[];
+  fix: string[];
+};
+
 type LaunchReadiness = {
   ready: boolean;
   fingerprint?: string;
@@ -568,38 +613,20 @@ export function businessHoursSchedule(timezone: string): SendSchedule {
   };
 }
 
-export const STEP_TYPES = [
-  "wait",
-  "email",
-  "linkedin_connection",
-  "linkedin_message",
-  "linkedin_visit",
-] as const;
-
-const STEP_KEYS = new Set([
-  "type",
-  "waitHours",
-  "emailMailboxAccountId",
-  "emailSubject",
-  "emailHtmlBody",
-  "emailTextBody",
-  "emailReplyToPrevious",
-  "onlyIf",
-  "linkedinAccountId",
-  "linkedinMessageBody",
-  "linkedinMessageMode",
-  "connectionTimeoutHours",
-]);
+export { STEP_TYPES };
+
+export type StepsFile = { steps: JsonRecord[]; warnings: string[] };
 
 /**
  * Parse a steps file: a JSON array of step objects (or `{ "steps": [...] }`).
  * Checks the shape the server validates so a typo is caught here with a
  * step number instead of a Convex validator message.
  */
-export function parseStepsJson(
+export function readStepsJson(
   raw: string,
   source = "The steps file",
-): JsonRecord[] {
+  options: { allowSingleBraces?: boolean } = {},
+): StepsFile {
   let parsed: unknown;
   try {
     parsed = JSON.parse(raw);
@@ -621,75 +648,28 @@ export function parseStepsJson(
   if (steps.length === 0) {
     throw new CampaignCliError(`${source} has no steps.`);
   }
-  if (steps.length > MAX_STEPS) {
+  const check = checkCampaignSteps(steps, {
+    allowSingleBraces: options.allowSingleBraces,
+    singleBraceOverride: "--allow-single-braces",
+  });
+  if (check.errors.length > 0) {
     throw new CampaignCliError(
-      `A campaign can have at most ${MAX_STEPS} steps.`,
+      check.errors.map((issue) => issue.message).join("\n"),
     );
   }
-  return steps.map((step, index) => {
-    const label = `Step ${index + 1}`;
-    if (!step || typeof step !== "object" || Array.isArray(step)) {
-      throw new CampaignCliError(`${label} must be an object with a "type".`);
-    }
-    const row = step as JsonRecord;
-    const type = row.type;
-    if (
-      typeof type !== "string" ||
-      !(STEP_TYPES as readonly string[]).includes(type)
-    ) {
-      throw new CampaignCliError(
-        `${label} has type ${JSON.stringify(type)}. Use one of: ${STEP_TYPES.join(", ")}.`,
-      );
-    }
-    const unknown = Object.keys(row).filter((key) => !STEP_KEYS.has(key));
-    if (unknown.length > 0) {
-      throw new CampaignCliError(
-        `${label} has keys the engine does not know: ${unknown.join(", ")}. Allowed: ${[...STEP_KEYS].join(", ")}.`,
-      );
-    }
-    if (type === "wait") {
-      if (typeof row.waitHours !== "number" || !(row.waitHours > 0)) {
-        throw new CampaignCliError(
-          `${label} is a wait step and needs "waitHours" above 0.`,
-        );
-      }
-    }
-    if (row.waitHours !== undefined && typeof row.waitHours !== "number") {
-      throw new CampaignCliError(
-        `${label}: "waitHours" must be a number of hours.`,
-      );
-    }
-    if (
-      row.onlyIf !== undefined &&
-      !["always", "connected", "not_connected"].includes(String(row.onlyIf))
-    ) {
-      throw new CampaignCliError(
-        `${label}: "onlyIf" must be always, connected or not_connected.`,
-      );
-    }
-    if (
-      row.linkedinMessageMode !== undefined &&
-      !["skip_if_not_connected", "wait_until_connected"].includes(
-        String(row.linkedinMessageMode),
-      )
-    ) {
-      throw new CampaignCliError(
-        `${label}: "linkedinMessageMode" must be skip_if_not_connected or wait_until_connected.`,
-      );
-    }
-    return row;
-  });
+  return { steps: steps as JsonRecord[], warnings: check.warnings };
 }
 
-/** The stored step reduced to the shape `steps set --file` accepts, so `steps get` round-trips. */
-export function stepToInput(step: JsonRecord): JsonRecord {
-  const input: JsonRecord = {};
-  for (const key of STEP_KEYS) {
-    if (step[key] !== undefined && step[key] !== null) input[key] = step[key];
-  }
-  return input;
+export function parseStepsJson(
+  raw: string,
+  source = "The steps file",
+  options: { allowSingleBraces?: boolean } = {},
+): JsonRecord[] {
+  return readStepsJson(raw, source, options).steps;
 }
 
+export { stepToInput };
+
 /**
  * A `--start`/`--end` value. A full timestamp is an instant already; a bare
  * date (`2026-09-03`) stays a date until the campaign's timezone is known,
@@ -944,7 +924,7 @@ export function hasScheduleChanges(patch: SchedulePatch): boolean {
   return Object.keys(patch).length > 0;
 }
 
-function localTimezone(): string {
+export function localTimezone(): string {
   return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
 }
 
@@ -1007,6 +987,8 @@ const STEP_LABELS: Record<string, string> = {
   linkedin_connection: "Connect on LinkedIn",
   linkedin_message: "LinkedIn message",
   linkedin_visit: "Visit profile",
+  linkedin_like_post: "React to a post",
+  linkedin_inmail: "LinkedIn InMail",
 };
 
 function stepLabel(step: { type: string; waitHours?: unknown }): string {
@@ -1048,6 +1030,9 @@ const NOW_VERBS: Record<string, string> = {
   profile: "Visiting the LinkedIn profile of",
   invite: "Sending a connection request to",
   message: "Sending a LinkedIn message to",
+  like: "Reacting to a recent post by",
+  inmail: "Sending an InMail to",
+  withdraw: "Withdrawing the pending invitation for",
   email: "Sending an email to",
 };
 
@@ -1056,6 +1041,9 @@ const NEXT_VERBS: Record<string, string> = {
   visit: "Visit the LinkedIn profile of",
   invite: "Send a connection request to",
   message: "Send a LinkedIn message to",
+  like: "React to a recent post by",
+  inmail: "Send an InMail to",
+  withdraw: "Withdraw the pending invitation for",
   email: "Send an email to",
   wait: "Wait for",
 };
@@ -1065,6 +1053,8 @@ const TOUCH_LABELS: Record<string, string> = {
   linkedin_connection: "invite sent",
   linkedin_message: "LinkedIn message sent",
   linkedin_visit: "profile visited",
+  linkedin_like_post: "post reaction sent",
+  linkedin_inmail: "InMail sent",
   wait: "wait finished",
 };
 
@@ -1299,10 +1289,48 @@ async function runCreate(ctx: CampaignCliContext): Promise<void> {
           `${formatWeekdays(s.weekdays)} ${s.startHour}-${s.endHour} ${s.timezone}`,
       )
       .join("; ")}`,
-    'Next: dench campaign steps set <campaign> --file steps.json, then dench campaign add <campaign> --object lead --view "<view>", then dench campaign launch <campaign>',
+    "Next: dench campaign steps set <campaign> --file steps.json",
+    'Add people: dench campaign search --titles Founder --limit 25 --out audience.json, then dench campaign add <campaign> --people-file audience.json (or --csv, --list, --object lead --view "<view>")',
+    "Then: dench campaign launch <campaign> --check",
   ]);
 }
 
+async function runDuplicate(ctx: CampaignCliContext): Promise<void> {
+  const name = valueFlag(ctx.args, "--name")?.trim();
+  if (name === "") {
+    throw new CampaignCliError("--name needs the name for the copy");
+  }
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign duplicate");
+  const row = await resolveCampaign(ctx, reference);
+  const created = (await callMutation(ctx, `${OUTREACH}:duplicateSequence`, {
+    sequenceId: row._id,
+  })) as { sequenceId: string };
+  if (name !== undefined) {
+    await callMutation(ctx, `${OUTREACH}:updateDraft`, {
+      sequenceId: created.sequenceId,
+      name,
+    });
+  }
+  const copyName = name ?? `${row.name} copy`;
+  const steps = row.stepCount ?? 0;
+  out(
+    ctx,
+    {
+      sequenceId: created.sequenceId,
+      name: copyName,
+      status: "draft",
+      duplicatedFrom: row._id,
+      stepCount: steps,
+      people: 0,
+    },
+    [
+      `Duplicated "${row.name}" as the draft "${copyName}" [${created.sequenceId}]: ${steps} ${steps === 1 ? "step" : "steps"}, the same schedule, senders and personalized lines, its lead source (paused), and nobody in it yet.`,
+      `Next: dench campaign add ${created.sequenceId} ... (up to ${MAX_CAMPAIGN_PEOPLE} people), then dench campaign launch ${created.sequenceId} --check`,
+    ],
+  );
+}
+
 async function runGet(ctx: CampaignCliContext): Promise<void> {
   const reference = shift(ctx.args, "campaign id or name");
   unknownFlags(ctx.args, "campaign get");
@@ -1393,7 +1421,9 @@ async function runGet(ctx: CampaignCliContext): Promise<void> {
       "  Next: nothing scheduled — everyone is finished, waiting on a reply, or stopped",
     );
   } else if (sequence.status === "draft") {
-    lines.push("  Next: launch it — dench campaign launch <campaign>");
+    lines.push(
+      "  Next: check it is ready — dench campaign launch <campaign> --check (launch only after the user says yes)",
+    );
   }
   if (live?.paused) {
     const reason =
@@ -1429,7 +1459,7 @@ async function runGet(ctx: CampaignCliContext): Promise<void> {
   lines.push("", `People (${shown.length} of ${enrollments.length})`);
   if (enrollments.length === 0) {
     lines.push(
-      '  nobody yet — dench campaign add <campaign> --object lead --view "<view>"',
+      "  nobody yet — dench campaign search --titles Founder --limit 25 --out audience.json, then dench campaign add <campaign> --people-file audience.json",
     );
   }
   for (const enrollment of shown)
@@ -1471,7 +1501,7 @@ async function runSet(ctx: CampaignCliContext): Promise<void> {
   }
   if (row.status === "archived") {
     throw new CampaignCliError(
-      "This campaign is archived and can't be changed. Duplicate it in the Dench app to start again.",
+      `This campaign is archived and can't be changed. Start again from a copy: dench campaign duplicate ${row._id}`,
     );
   }
   // One updateDraft carries the rename too, so the server accepts or rejects
@@ -1504,30 +1534,43 @@ async function runSet(ctx: CampaignCliContext): Promise<void> {
   ]);
 }
 
+const STEPS_ACTIONS: Record<string, string> = {
+  get: "get",
+  show: "get",
+  set: "set",
+  replace: "set",
+  edit: "edit",
+  update: "edit",
+};
+
 async function runSteps(ctx: CampaignCliContext): Promise<void> {
   const file = valueFlag(ctx.args, "--file");
-  let action = ctx.args[0];
-  if (
-    action === "get" ||
-    action === "set" ||
-    action === "show" ||
-    action === "replace"
-  ) {
-    ctx.args.shift();
-    action = action === "show" ? "get" : action === "replace" ? "set" : action;
-  } else {
-    action = file ? "set" : "get";
-  }
+  const allowSingleBraces = hasFlag(ctx.args, "--allow-single-braces");
+  const withIds = hasFlag(ctx.args, "--with-ids");
+  let action = STEPS_ACTIONS[ctx.args[0] ?? ""];
+  if (action) ctx.args.shift();
+  else action = file ? "set" : "get";
   const reference = shift(ctx.args, "campaign id or name");
   unknownFlags(ctx.args, `campaign steps ${action}`);
+  if (withIds && action !== "get") {
+    throw new CampaignCliError(
+      "--with-ids is for steps get. steps edit reads stepId and updatedAt from the file.",
+    );
+  }
   const row = await resolveCampaign(ctx, reference);
   if (action === "get") {
     const detail = await loadDetail(ctx, String(row._id));
     const steps = [...detail.steps]
       .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
-      .map((step) => stepToInput(step));
-    // Always JSON: the point of `steps get` is a file you can edit and feed
-    // back to `steps set --file`.
+      .map((step) =>
+        withIds
+          ? {
+              stepId: String(step._id),
+              updatedAt: step.updatedAt,
+              ...stepToInput(step),
+            }
+          : stepToInput(step),
+      );
     console.log(JSON.stringify(steps, null, 2));
     return;
   }
@@ -1536,26 +1579,138 @@ async function runSteps(ctx: CampaignCliContext): Promise<void> {
       "Missing required --file steps.json (a JSON array of steps).",
     );
   }
+  if (action === "edit") return runStepsEdit(ctx, row, file, allowSingleBraces);
   if (row.status !== "draft") {
     throw new CampaignCliError(
-      "steps set only works while a campaign is a draft. After launch, edit a step's text or wait time in the Dench app (the step types and order stay fixed).",
+      `steps set only works while a campaign is a draft. After launch, change a step's text or wait in place: dench campaign steps get ${row._id} --with-ids > steps.json, edit it, then dench campaign steps edit ${row._id} --file steps.json (the number, order and types of steps stay fixed).`,
     );
   }
   const raw = await readFile(file, "utf8").catch(() => {
     throw new CampaignCliError(`Cannot read ${file}`);
   });
-  const steps = parseStepsJson(raw, file);
+  const { steps, warnings } = readStepsJson(raw, file, { allowSingleBraces });
+  if (steps.some(hasHtmlAndTextBody)) {
+    const stored = (await loadDetail(ctx, String(row._id))).steps;
+    for (const index of staleHtmlSteps(steps, stored)) {
+      delete steps[index].emailHtmlBody;
+      warnings.push(staleHtmlWarning(index));
+    }
+  }
   const result = (await callMutation(ctx, `${OUTREACH}:replaceSteps`, {
     sequenceId: row._id,
     steps,
   })) as { ok: true; stepCount: number };
-  out(ctx, { ...result, sequenceId: row._id, steps }, [
+  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}`),
   ]);
 }
 
+function stepsInFile(parsed: unknown): unknown[] | null {
+  if (Array.isArray(parsed)) return parsed;
+  if (
+    parsed &&
+    typeof parsed === "object" &&
+    Array.isArray((parsed as JsonRecord).steps)
+  )
+    return (parsed as JsonRecord).steps as unknown[];
+  return null;
+}
+
+async function runStepsEdit(
+  ctx: CampaignCliContext,
+  row: CampaignRow,
+  file: string,
+  allowSingleBraces: boolean,
+): Promise<void> {
+  if (row.status === "archived") {
+    throw new CampaignCliError(
+      `"${row.name}" is archived, so its steps can't change. Start again from a copy: dench campaign duplicate ${row._id}`,
+    );
+  }
+  const raw = await readFile(file, "utf8").catch(() => {
+    throw new CampaignCliError(`Cannot read ${file}`);
+  });
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CampaignCliError(`${file} is not valid JSON.`);
+  }
+  const entries = stepsInFile(parsed);
+  if (!entries) {
+    throw new CampaignCliError(
+      `${file} must be a JSON array of steps (or an object with a "steps" array), like dench campaign steps get ${row._id} --with-ids prints.`,
+    );
+  }
+  const detail = await loadDetail(ctx, String(row._id));
+  const status = detail.sequence.status ?? row.status;
+  const draft = status === "draft";
+  let plan: ReturnType<typeof planStepEdits>;
+  try {
+    plan = planStepEdits(detail.steps, entries, {
+      allowSingleBraces,
+      singleBraceOverride: "--allow-single-braces",
+      campaign: String(row._id),
+      draft,
+    });
+  } catch (error) {
+    if (error instanceof StepEditError)
+      throw new CampaignCliError(error.message);
+    throw error;
+  }
+  const warningLines = plan.warnings.map((warning) => `Warning: ${warning}`);
+  if (plan.changes.length === 0) {
+    out(
+      ctx,
+      {
+        ok: true,
+        sequenceId: row._id,
+        status,
+        changed: [],
+        warnings: plan.warnings,
+      },
+      [
+        `No step in ${file} differs from "${row.name}", so nothing was saved.`,
+        ...warningLines,
+      ],
+    );
+    return;
+  }
+  if (draft) {
+    await callMutation(ctx, `${OUTREACH}:replaceSteps`, {
+      sequenceId: row._id,
+      steps: plan.steps,
+    });
+  } else {
+    await callMutation(ctx, `${OUTREACH}:updateSteps`, {
+      sequenceId: row._id,
+      steps: plan.updates,
+    });
+  }
+  out(
+    ctx,
+    {
+      ok: true,
+      sequenceId: row._id,
+      status,
+      saved: draft ? "replaced" : "updated in place",
+      changed: plan.changes,
+      warnings: plan.warnings,
+    },
+    [
+      `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(", ")}`,
+      ),
+      ...warningLines,
+    ],
+  );
+}
+
 function emptyTotals(): EnrollFromCrmResult {
   return {
     added: 0,
@@ -1703,7 +1858,7 @@ function describeEnrollTotals(
   }
   if (totals.duplicatesElsewhere > 0) {
     lines.push(
-      `  Active in another campaign, skipped: ${totals.duplicatesElsewhere} (pass --allow-duplicates to add anyway)`,
+      `  Enrolled in another campaign, skipped: ${totals.duplicatesElsewhere} (pass --allow-duplicates to add anyway)`,
     );
   }
   if (totals.suppressed > 0)
@@ -1738,6 +1893,7 @@ function describeEnrollTotals(
 }
 
 async function runAdd(ctx: CampaignCliContext): Promise<void> {
+  if (usesSearchFlags(ctx.args)) return runAgentCommand(ctx, "add");
   const objectName = valueFlag(ctx.args, "--object");
   const viewName = valueFlag(ctx.args, "--view");
   const entriesRaw = valueFlag(ctx.args, "--entries");
@@ -1754,7 +1910,7 @@ async function runAdd(ctx: CampaignCliContext): Promise<void> {
   unknownFlags(ctx.args, "campaign add");
 
   const usage =
-    'Usage: dench campaign add <campaign> --object <name> --view "<view>" | --object <name> --entries id1,id2 | [--name "Ada"] --email ada@x.com and/or --linkedin-url https://linkedin.com/in/ada';
+    'Usage: dench campaign add <campaign> --titles Founder --locations "United States" | --search \'{"titles":["Founder"]}\' | --people-file audience.json | --csv people.csv | --list <artifactId> | --object <name> --view "<view>" | --object <name> --entries id1,id2 | [--name "Ada"] --email ada@x.com and/or --linkedin-url https://linkedin.com/in/ada';
   const row = await resolveCampaign(ctx, reference);
   if (row.status === "archived") {
     throw new CampaignCliError(
@@ -1856,7 +2012,7 @@ async function runAdd(ctx: CampaignCliContext): Promise<void> {
   }
   if (!email && !linkedinProfileUrl) {
     throw new CampaignCliError(
-      `Pass --email and/or --linkedin-url for one person, or --object with --view/--entries for CRM records. ${usage}`,
+      `Pass --email and/or --linkedin-url for one person, --object with --view/--entries for CRM records, or search filters (--titles, --search), --people-file, --csv or --list. ${usage}`,
     );
   }
   const result = (await callMutation(ctx, `${OUTREACH}:addEnrollment`, {
@@ -1871,31 +2027,272 @@ async function runAdd(ctx: CampaignCliContext): Promise<void> {
   ]);
 }
 
-function describeBlockers(readiness: LaunchReadiness): string[] {
-  const lines: string[] = [];
+const STEP_BLOCKER_REASONS: Record<string, RegExp> = {
+  email_sender_missing: /sender is missing|needs a sender mailbox/i,
+  linkedin_sender_missing: /sender is missing|needs a sender account/i,
+  email_sender_foreign: /sender is private to another member/i,
+  linkedin_sender_foreign: /sender is private to another member/i,
+  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,
+};
+
+function blockerReasons(
+  group: LaunchBlockerGroup,
+  reasons: readonly string[],
+): string[] {
+  if (typeof group.stepIndex !== "number") return [];
+  const step = new RegExp(`\\bstep ${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));
+  return forStep.filter(
+    (reason) =>
+      !Object.values(STEP_BLOCKER_REASONS).some((pattern) =>
+        pattern.test(reason),
+      ),
+  );
+}
+
+const STEPS_FIX = (id: string) => [
+  `dench campaign steps get ${id} > steps.json`,
+  `dench campaign steps set ${id} --file steps.json`,
+];
+
+const BLOCKER_FIXES: Record<string, (id: string) => string[]> = {
+  no_steps: STEPS_FIX,
+  too_many_steps: STEPS_FIX,
+  step_invalid: STEPS_FIX,
+  reply_without_prior_email: STEPS_FIX,
+  person_empty_subject: STEPS_FIX,
+  person_empty_email_body: STEPS_FIX,
+  person_empty_linkedin_message: STEPS_FIX,
+  person_linkedin_message_too_long: STEPS_FIX,
+  person_missing_email_fields: STEPS_FIX,
+  person_missing_linkedin_fields: STEPS_FIX,
+  too_many_prospects: (id) => [
+    `dench campaign people ${id}`,
+    `dench campaign remove ${id} --person <enrollmentId>`,
+  ],
+  linkedin_duplicate_conflict: (id) => [
+    `dench campaign people ${id}`,
+    `dench campaign remove ${id} --person <enrollmentId>`,
+    "dench campaign archive <otherDraftCampaign>",
+    "dench campaign stop <otherCampaign> --person <otherEnrollmentId>",
+  ],
+  person_duplicate_sequence: () => [
+    "dench campaign list",
+    "dench campaign archive <otherDraftCampaign>",
+    "dench campaign stop <otherCampaign> --person <otherEnrollmentId>",
+  ],
+  no_prospects: (id) => [
+    `dench campaign add ${id} --titles "<title>" --locations "<location>"`,
+    `dench campaign add ${id} --people-file audience.json`,
+  ],
+  missing_business_hours: (id) => [
+    `dench campaign set ${id} --timezone <IANA timezone> --window "Mon-Fri 9-18"`,
+  ],
+  email_sender_missing: (id) => [
+    "dench campaign accounts",
+    `dench campaign set ${id} --email-mailboxes <emailMailboxAccountId>`,
+  ],
+  email_sender_foreign: (id) => [
+    "dench campaign accounts",
+    `dench campaign set ${id} --email-mailboxes <emailMailboxAccountId>`,
+  ],
+  email_sender_disconnected: (id) => [
+    "dench campaign accounts",
+    `dench campaign set ${id} --email-mailboxes <emailMailboxAccountId>`,
+  ],
+  linkedin_sender_missing: (id) => [
+    "dench campaign accounts",
+    `dench campaign set ${id} --linkedin-accounts <linkedinAccountId>`,
+  ],
+  linkedin_sender_foreign: (id) => [
+    "dench campaign accounts",
+    `dench campaign set ${id} --linkedin-accounts <linkedinAccountId>`,
+  ],
+  linkedin_sender_disconnected: (id) => [
+    "dench campaign accounts",
+    `dench campaign set ${id} --linkedin-accounts <linkedinAccountId>`,
+  ],
+};
+
+const REMOVABLE_BLOCKERS = new Set([
+  "audience_already_started",
+  "person_no_channel",
+  "person_invalid_email",
+  "person_suppressed",
+  "person_duplicate_sequence",
+  "person_missing_email_fields",
+  "person_missing_linkedin_fields",
+]);
+
+const MAX_REMOVE_FIXES = 5;
+
+function removeFixes(group: LaunchBlockerGroup, sequenceId: string): string[] {
+  const ids = group.people.flatMap((person) =>
+    person.enrollmentId ? [person.enrollmentId] : [],
+  );
+  if (!ids.length)
+    return [`dench campaign remove ${sequenceId} --person <enrollmentId>`];
+  return [
+    ...ids
+      .slice(0, MAX_REMOVE_FIXES)
+      .map((id) => `dench campaign remove ${sequenceId} --person ${id}`),
+    ...(ids.length > MAX_REMOVE_FIXES
+      ? [`dench campaign people ${sequenceId}`]
+      : []),
+  ];
+}
+
+const PERSON_SET_FIXES: Record<
+  string,
+  (person: LaunchBlockerGroup["people"][number]) => string
+> = {
+  person_no_channel: () => "--email <address> and/or --linkedin-url <url>",
+  person_invalid_email: () => "--email <address>",
+  person_missing_email_fields: (person) => fieldFlags(person),
+  person_missing_linkedin_fields: (person) => fieldFlags(person),
+};
+
+function fieldFlags(person: LaunchBlockerGroup["people"][number]): string {
+  const keys = (person.fields ?? []).map((field) => field.key);
+  return keys.length
+    ? keys.map((key) => `--field "${key}=<value>"`).join(" ")
+    : '--field "<Field>=<value>"';
+}
+
+function personSetFixes(
+  group: LaunchBlockerGroup,
+  sequenceId: string,
+): string[] {
+  const flags = PERSON_SET_FIXES[group.code];
+  if (!flags) return [];
+  return group.people
+    .filter((person) => person.enrollmentId)
+    .slice(0, MAX_REMOVE_FIXES)
+    .map(
+      (person) =>
+        `dench campaign person set ${sequenceId} --person ${person.enrollmentId} ${flags(person)}`,
+    );
+}
+
+export function explainBlockers(
+  readiness: LaunchReadiness,
+  sequenceId: string,
+): ExplainedBlocker[] {
+  const reasons = readiness.blockingReasons ?? [];
   const groups = readiness.blockers ?? [];
-  if (groups.length > 0) {
-    for (const group of groups) {
-      const step =
-        typeof group.stepIndex === "number"
-          ? ` (step ${group.stepIndex + 1})`
-          : "";
-      const names = group.people.slice(0, 3).map((person) => person.name);
-      const more =
-        group.people.length > 3 ? `, +${group.people.length - 3} more` : "";
-      const who = names.length > 0 ? ` — ${names.join(", ")}${more}` : "";
-      lines.push(
-        `  - ${group.title}${step}${who}${group.hint ? ` ${group.hint}` : ""}`,
-      );
-    }
-  } else {
-    for (const reason of readiness.blockingReasons ?? [])
-      lines.push(`  - ${reason}`);
+  if (!groups.length)
+    return reasons.map((reason) => ({
+      code: "blocked",
+      title: reason,
+      people: [],
+      count: 1,
+      reasons: [],
+      fix: [],
+    }));
+  return groups.map((group) => ({
+    ...group,
+    reasons: blockerReasons(group, reasons),
+    fix: [
+      ...(BLOCKER_FIXES[group.code]?.(sequenceId) ?? []),
+      ...personSetFixes(group, sequenceId),
+      ...(REMOVABLE_BLOCKERS.has(group.code)
+        ? removeFixes(group, sequenceId)
+        : []),
+    ],
+  }));
+}
+
+function describeBlockers(blockers: readonly ExplainedBlocker[]): string[] {
+  const lines: string[] = [];
+  for (const group of blockers) {
+    const step =
+      typeof group.stepIndex === "number"
+        ? ` (step ${group.stepIndex + 1})`
+        : "";
+    const names = group.people.slice(0, 3).map((person) => {
+      const fields = (person.fields ?? []).map((field) => field.label);
+      return fields.length
+        ? `${person.name} (missing ${fields.join(", ")})`
+        : person.name;
+    });
+    const more =
+      group.people.length > 3 ? `, +${group.people.length - 3} more` : "";
+    const who = names.length > 0 ? ` — ${names.join(", ")}${more}` : "";
+    lines.push(`  - ${group.title}${step}${who}`);
+    for (const reason of group.reasons) lines.push(`      why: ${reason}`);
+    if (group.hint) lines.push(`      ${group.hint}`);
+    for (const command of group.fix) lines.push(`      fix: ${command}`);
   }
   return lines;
 }
 
+function readinessCounts(readiness: LaunchReadiness): string {
+  const channels = [
+    readiness.usesEmail ? "email" : "",
+    readiness.usesLinkedin ? "LinkedIn" : "",
+  ].filter(Boolean);
+  const people = readiness.audienceCount ?? 0;
+  const steps = readiness.stepCount ?? 0;
+  return `${people} ${people === 1 ? "person" : "people"}, ${steps} ${steps === 1 ? "step" : "steps"}${channels.length ? ` (${channels.join(" and ")})` : ""}`;
+}
+
+function launchCommand(row: CampaignRow, readiness: LaunchReadiness): string {
+  return `dench campaign launch ${row._id}${readiness.usesLinkedin ? " --ack-linkedin-risk" : ""}`;
+}
+
+async function runLaunchCheck(
+  ctx: CampaignCliContext,
+  row: CampaignRow,
+  readiness: LaunchReadiness,
+): Promise<void> {
+  const ready =
+    readiness.ready === true && typeof readiness.fingerprint === "string";
+  const blockers = explainBlockers(readiness, String(row._id));
+  const warnings = readiness.warnings ?? [];
+  const payload = {
+    sequenceId: row._id,
+    name: row.name,
+    status: row.status,
+    ready,
+    fingerprint: readiness.fingerprint ?? null,
+    audienceCount: readiness.audienceCount ?? 0,
+    stepCount: readiness.stepCount ?? 0,
+    usesEmail: readiness.usesEmail === true,
+    usesLinkedin: readiness.usesLinkedin === true,
+    needsLinkedinAck: readiness.usesLinkedin === true,
+    blockers,
+    warnings,
+    next: ready
+      ? launchCommand(row, readiness)
+      : `dench campaign launch ${row._id} --check`,
+  };
+  const lines = ready
+    ? [`"${row.name}" is ready to launch: ${readinessCounts(readiness)}.`]
+    : [
+        `"${row.name}" is not ready to launch (${blockers.length} ${blockers.length === 1 ? "blocker" : "blockers"}; ${readinessCounts(readiness)}):`,
+        ...describeBlockers(blockers),
+      ];
+  if (warnings.length)
+    lines.push("Warnings:", ...warnings.map((warning) => `  - ${warning}`));
+  lines.push(`Fingerprint: ${readiness.fingerprint ?? "none"}`);
+  lines.push(
+    ready
+      ? `Nothing was launched. After the user says yes: ${launchCommand(row, readiness)}${readiness.usesLinkedin ? " (LinkedIn steps need the account owner to accept the LinkedIn risk)" : ""}`
+      : `Nothing was launched. Fix the blockers, then run: dench campaign launch ${row._id} --check`,
+  );
+  out(ctx, payload, lines);
+  if (!ready)
+    throw new CampaignCliError(
+      `"${row.name}" is not ready to launch: ${blockers.length} ${blockers.length === 1 ? "blocker" : "blockers"}. Nothing was launched.`,
+    );
+}
+
 async function runLaunch(ctx: CampaignCliContext): Promise<void> {
+  const check = hasFlag(ctx.args, "--check");
   const ack = hasFlag(ctx.args, "--ack-linkedin-risk");
   const reference = shift(ctx.args, "campaign id or name");
   unknownFlags(ctx.args, "campaign launch");
@@ -1910,10 +2307,11 @@ async function runLaunch(ctx: CampaignCliContext): Promise<void> {
   const readiness = (await callQuery(ctx, `${OUTREACH}:previewLaunch`, {
     sequenceId: row._id,
   })) as LaunchReadiness;
+  if (check) return runLaunchCheck(ctx, row, readiness);
   if (readiness.ready !== true || typeof readiness.fingerprint !== "string") {
     const lines = [
       `"${row.name}" is not ready to launch:`,
-      ...describeBlockers(readiness),
+      ...describeBlockers(explainBlockers(readiness, String(row._id))),
     ];
     if ((readiness.warnings ?? []).length > 0) {
       lines.push(
@@ -1959,9 +2357,10 @@ async function runLaunch(ctx: CampaignCliContext): Promise<void> {
 async function runLifecycle(
   ctx: CampaignCliContext,
   action: "pause" | "resume" | "archive",
+  invoked: string = action,
 ): Promise<void> {
   const reference = shift(ctx.args, "campaign id or name");
-  unknownFlags(ctx.args, `campaign ${action}`);
+  unknownFlags(ctx.args, `campaign ${invoked}`);
   const row = await resolveCampaign(ctx, reference);
   const already =
     action === "pause"
@@ -1985,7 +2384,7 @@ async function runLifecycle(
   if (action === "resume" && row.status !== "paused") {
     throw new CampaignCliError(
       row.status === "draft"
-        ? `"${row.name}" is a draft. Launch it with: dench campaign launch <campaign>`
+        ? `"${row.name}" is a draft, not a paused campaign. Check it with: dench campaign launch ${row._id} --check, then launch it once the user says yes.`
         : `Only a paused campaign can be resumed. "${row.name}" is ${row.status}.`,
     );
   }
@@ -2006,6 +2405,11 @@ async function runLifecycle(
         : "Archived";
   out(ctx, { ok: true, sequenceId: row._id, status, changed: true }, [
     `${verb} "${row.name}".${action === "archive" ? " Everyone still in flight was stopped." : ""}`,
+    ...(invoked === "delete"
+      ? [
+          "Campaigns are archived, not erased: it leaves dench campaign list, and its people, leads and activity stay. dench campaign list --all still shows it.",
+        ]
+      : []),
   ]);
 }
 
@@ -2072,75 +2476,717 @@ function resolvePerson(detail: CampaignDetail, reference: string): Enrollment {
   );
 }
 
-async function runPerson(
+async function removeEnrollment(
   ctx: CampaignCliContext,
-  action: "stop" | "resume-person",
+  enrollmentId: string,
 ): Promise<void> {
+  await callMutation(ctx, `${OUTREACH}:removeDraftEnrollment`, {
+    enrollmentId,
+  });
+}
+
+async function runRemove(ctx: CampaignCliContext): Promise<void> {
   const person = requiredFlag(ctx.args, "--person");
   const reference = shift(ctx.args, "campaign id or name");
-  unknownFlags(ctx.args, `campaign ${action}`);
+  unknownFlags(ctx.args, "campaign remove");
   const row = await resolveCampaign(ctx, reference);
-  const detail = await loadDetail(ctx, String(row._id));
-  const enrollment = resolvePerson(detail, person);
-  const name = enrollment.displayName?.trim() || enrollment._id;
-  if (action === "stop") {
-    if (
-      [
-        "finished",
-        "stopped",
-        "replied",
-        "bounced",
-        "complained",
-        "unsubscribed",
-        "failed",
-      ].includes(enrollment.status)
-    ) {
-      out(
-        ctx,
-        {
-          ok: true,
-          enrollmentId: enrollment._id,
-          status: enrollment.status,
-          changed: false,
-        },
-        [`${name} is already ${enrollment.status}; nothing more will be sent.`],
-      );
-      return;
-    }
-    await callMutation(ctx, `${OUTREACH}:stopEnrollment`, {
-      enrollmentId: enrollment._id,
-    });
-    out(
-      ctx,
-      {
-        ok: true,
-        enrollmentId: enrollment._id,
-        status: "stopped",
-        changed: true,
-      },
-      [
-        `Stopped ${name} in "${row.name}". They will get nothing more from this campaign.`,
-      ],
-    );
-    return;
-  }
-  if (enrollment.status !== "paused") {
+  if (row.status !== "draft") {
     throw new CampaignCliError(
-      `${name} is ${enrollment.status}, not paused. Only a paused person can be resumed.`,
+      `Only a draft campaign's people can be removed; "${row.name}" is ${row.status}. To make sure nothing more is sent to someone, use: dench campaign stop ${row._id} --person <enrollmentId>`,
     );
   }
-  if (row.status !== "active") {
+  const detail = await loadDetail(ctx, String(row._id));
+  const enrollment = resolvePerson(detail, person);
+  const name = enrollment.displayName?.trim() || enrollment._id;
+  if (enrollment.firstContactedAt !== undefined) {
     throw new CampaignCliError(
-      `Resume the campaign first: dench campaign resume ${row._id}`,
+      `${name} has already been contacted, so they can't be removed. Use: dench campaign stop ${row._id} --person ${enrollment._id}`,
     );
   }
-  await callMutation(ctx, `${OUTREACH}:resumeEnrollment`, {
-    enrollmentId: enrollment._id,
-  });
+  await removeEnrollment(ctx, enrollment._id);
   out(
     ctx,
-    { ok: true, enrollmentId: enrollment._id, status: "active", changed: true },
-    [`Resumed ${name} in "${row.name}".`],
+    {
+      ok: true,
+      sequenceId: row._id,
+      enrollmentId: enrollment._id,
+      status: "removed",
+      changed: true,
+    },
+    [
+      `Removed ${name} from the draft "${row.name}". Nothing had been sent to them, and their place in the ${MAX_CAMPAIGN_PEOPLE}-person cap is free again.`,
+    ],
+  );
+}
+
+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" ...]';
+
+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 value = at === -1 ? "" : raw.slice(at + 1).trim();
+    if (!key || !value) {
+      throw new CampaignCliError(
+        `--field "${raw}" needs a name and a value, e.g. --field "Job Title=CTO" for {{Job Title}}.`,
+      );
+    }
+    return { key, value };
+  });
+}
+
+function errorText(error: unknown): string {
+  if (
+    error &&
+    typeof error === "object" &&
+    "data" in error &&
+    typeof (error as { data: unknown }).data === "string"
+  )
+    return (error as { data: string }).data;
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function runPersonSet(ctx: CampaignCliContext): Promise<void> {
+  const person = requiredFlag(ctx.args, "--person");
+  const email = valueFlag(ctx.args, "--email")?.trim();
+  const linkedinProfileUrl = valueFlag(ctx.args, "--linkedin-url")?.trim();
+  const fields = parseFieldFlags(getAllFlags(ctx.args, "--field"));
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign person set");
+  if (email === "" || linkedinProfileUrl === "") {
+    throw new CampaignCliError(
+      `--email and --linkedin-url need a value. ${PERSON_SET_USAGE}`,
+    );
+  }
+  if (!email && !linkedinProfileUrl && fields.length === 0) {
+    throw new CampaignCliError(
+      `Nothing to change. Pass --email, --linkedin-url and/or --field "Name=Value". ${PERSON_SET_USAGE}`,
+    );
+  }
+  const row = await resolveCampaign(ctx, reference);
+  const detail = await loadDetail(ctx, String(row._id));
+  const enrollment = resolvePerson(detail, person);
+  const name = enrollment.displayName?.trim() || enrollment._id;
+  if (enrollment.status !== "draft") {
+    throw new CampaignCliError(
+      `${name} is ${enrollment.status}. A person's email, LinkedIn URL and fields can only change before the campaign launches. To reach them at a new address, stop them and add them again: dench campaign stop ${row._id} --person ${enrollment._id}, then dench campaign add ${row._id} --email <address> and/or --linkedin-url <url>.`,
+    );
+  }
+  const lineKeys = new Set(
+    (row.personalizationTemplate?.variables ?? []).map((variable) =>
+      normalizedLineKey(variable.key),
+    ),
+  );
+  const line = fields.find((field) =>
+    lineKeys.has(normalizedLineKey(field.key)),
+  );
+  if (line) {
+    throw new CampaignCliError(
+      `{{${line.key}}} is a personalized line, not a merge field. Set it with: dench campaign personalize edit ${row._id} --person ${enrollment._id} --line ${line.key} --text "${line.value}". Nothing was saved.`,
+    );
+  }
+  const saved: string[] = [];
+  const save = async (label: string, fn: string, args: JsonRecord) => {
+    try {
+      await callMutation(ctx, `${OUTREACH}:${fn}`, {
+        enrollmentId: enrollment._id,
+        ...args,
+      });
+    } catch (error) {
+      throw new CampaignCliError(
+        `Could not save ${label}: ${errorText(error)}${saved.length ? ` Already saved: ${saved.join(", ")}.` : " Nothing was saved."}`,
+      );
+    }
+    saved.push(label);
+  };
+  if (email) await save("the email", "updateEnrollmentEmail", { email });
+  if (linkedinProfileUrl)
+    await save("the LinkedIn URL", "updateEnrollmentLinkedin", {
+      linkedinProfileUrl,
+    });
+  for (const field of fields)
+    await save(`{{${field.key}}}`, "updateEnrollmentMergeField", field);
+  const parts = [
+    ...(email ? [`email ${email}`] : []),
+    ...(linkedinProfileUrl ? [`LinkedIn ${linkedinProfileUrl}`] : []),
+    ...fields.map((field) => `{{${field.key}}} = ${field.value}`),
+  ];
+  out(
+    ctx,
+    {
+      ok: true,
+      sequenceId: row._id,
+      enrollmentId: enrollment._id,
+      updated: {
+        ...(email ? { email } : {}),
+        ...(linkedinProfileUrl ? { linkedinProfileUrl } : {}),
+        ...(fields.length
+          ? {
+              fields: Object.fromEntries(
+                fields.map((field) => [field.key, field.value]),
+              ),
+            }
+          : {}),
+      },
+    },
+    [
+      `Updated ${name} in "${row.name}": ${parts.join(" · ")}.`,
+      `Check the campaign again: dench campaign launch ${row._id} --check`,
+    ],
+  );
+}
+
+const PERSON_SHOW_USAGE =
+  "dench campaign person show <campaign> --person <enrollmentId|name>";
+
+const SENT_TEXT_LINES = 6;
+
+async function runPersonShow(ctx: CampaignCliContext): Promise<void> {
+  const person = requiredFlag(ctx.args, "--person");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign person show");
+  const row = await resolveCampaign(ctx, reference);
+  const detail = await loadDetail(ctx, String(row._id));
+  const enrollment = resolvePerson(detail, person);
+  const timeline = (await callQuery(ctx, `${OUTREACH}:timeline`, {
+    enrollmentId: enrollment._id,
+  })) as TimelineResult;
+  const steps = timelineSteps(timeline);
+  const described = describePerson(enrollment, detail);
+  const address = personAddress(timeline.enrollment);
+  const stepDocs = new Map(
+    timeline.steps.map((step) => [String(step._id), step]),
+  );
+  const lines = [described.line];
+  const contact = [address.email, address.linkedinProfileUrl].filter(Boolean);
+  if (contact.length) lines.push(`  ${contact.join(" · ")}`);
+  if (!steps.length) {
+    lines.push("  Nothing has happened for this person yet.");
+  }
+  for (const step of steps) {
+    const doc = stepDocs.get(step.stepId);
+    const label = stepLabel(doc ?? { type: step.type });
+    const when = step.at === null ? "" : ` · ${fmtRelative(step.at)}`;
+    lines.push(
+      `  Step ${step.step} · ${label} · ${[step.outcome, ...step.detail].join(" · ")}${when}`,
+    );
+    if (step.subject) lines.push(`      Subject: ${step.subject}`);
+    if (step.text) {
+      const body = step.text.split("\n");
+      lines.push(
+        ...body.slice(0, SENT_TEXT_LINES).map((line) => `      ${line}`),
+      );
+      if (body.length > SENT_TEXT_LINES) lines.push("      …");
+    }
+    if (step.error) lines.push(`      ${step.error}`);
+  }
+  out(
+    ctx,
+    {
+      sequenceId: row._id,
+      ...described.json,
+      ...address,
+      steps,
+    },
+    lines,
+  );
+}
+
+async function runPersonCommand(ctx: CampaignCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  if (verb === "set") return runPersonSet(ctx);
+  if (verb === "show" || verb === "get" || verb === "history")
+    return runPersonShow(ctx);
+  throw new CampaignCliError(
+    `Use one of:\n  ${PERSON_SET_USAGE}\n  ${PERSON_SHOW_USAGE}`,
+  );
+}
+
+const PERSONALIZE = "functions/outreachPersonalization";
+
+type PersonalizationStatus = {
+  template: (LineTemplate & { version?: number }) | null;
+  counts: { done: number; pending: number; failed: number; total: number };
+  paused: boolean;
+  notice: { code: string; at: number } | null;
+  suggestedContext: { sells?: string };
+  estimatedCentsPerPerson: number;
+  eligible: number;
+};
+
+type BackfillResult = {
+  version: number;
+  eligible: number;
+  estimatedCents: number;
+  needsConfirm: boolean;
+  queued: number;
+};
+
+const PERSONALIZE_USAGE = [
+  "dench campaign personalize get <campaign>",
+  "dench campaign personalize set <campaign> --file lines.json",
+  "dench campaign personalize write <campaign> [--all] [--yes]",
+  'dench campaign personalize edit <campaign> --person <enrollmentId|name> --line <key> --text "..."',
+  "dench campaign personalize rewrite <campaign> --person <enrollmentId|name> [--line <key>]",
+  "dench campaign personalize clear <campaign>",
+];
+
+function plural(count: number, one: string, many: string): string {
+  return `${count} ${count === 1 ? one : many}`;
+}
+
+async function personalizationStatus(
+  ctx: CampaignCliContext,
+  sequenceId: string,
+): Promise<PersonalizationStatus> {
+  return (await callQuery(ctx, `${PERSONALIZE}:getStatus`, {
+    sequenceId,
+  })) as PersonalizationStatus;
+}
+
+function linesText(row: CampaignRow, status: PersonalizationStatus): string[] {
+  const template = status.template;
+  if (!template?.variables.length) {
+    return [
+      `"${row.name}" has no personalized lines.`,
+      `Add up to 5 AI-written lines, about ${formatCents(status.estimatedCentsPerPerson || LINE_CENTS_PER_PERSON)} a person: dench campaign personalize set ${row._id} --file lines.json`,
+    ];
+  }
+  const lines = [
+    `Personalized lines in "${row.name}" (${template.variables.length}):`,
+  ];
+  for (const variable of template.variables) {
+    lines.push(
+      `  {{${variable.key}}}  ${variable.label} — up to ${variable.maxChars ?? 200} characters${variable.fallbackFrom ? `; without a line, uses {{${variable.fallbackFrom}}}` : ""}`,
+      `      instructions: ${variable.prompt}`,
+      `      fallback: ${variable.fallback}`,
+    );
+  }
+  lines.push(`What you sell: ${template.context.sells}`);
+  if (template.context.offer) lines.push(`Offer: ${template.context.offer}`);
+  const { done, pending, failed, total } = status.counts;
+  lines.push(
+    `Written for ${done} of ${plural(total, "person", "people")}${pending ? ` · ${pending} ${status.paused ? "waiting for the campaign to resume" : "being written"}` : ""}${failed ? ` · ${failed} using the fallback` : ""} · about ${formatCents(status.estimatedCentsPerPerson)} a person`,
+  );
+  if (status.eligible > 0 && pending === 0)
+    lines.push(
+      `${plural(status.eligible, "person needs", "people need")} lines: dench campaign personalize write ${row._id}`,
+    );
+  if (status.notice?.code === "insufficient_credits")
+    lines.push(
+      `Writing stopped because the workspace ran out of credits. Add credits, then run dench campaign personalize write ${row._id}`,
+    );
+  return lines;
+}
+
+function backfillText(row: CampaignRow, result: BackfillResult): string {
+  if (result.needsConfirm)
+    return `${plural(result.eligible, "person needs", "people need")} lines, about ${formatCents(result.estimatedCents)}. Nothing was written yet; confirm with: dench campaign personalize write ${row._id} --yes`;
+  if (result.queued > 0)
+    return `Writing lines for ${plural(result.queued, "person", "people")} now, about ${formatCents(result.estimatedCents)}. Messages wait up to 2 hours for a person's line, then use its fallback.`;
+  return "Nobody needs a new line right now.";
+}
+
+async function readJsonFile(file: string): Promise<unknown> {
+  const raw = await readFile(file, "utf8").catch(() => {
+    throw new CampaignCliError(`Cannot read ${file}`);
+  });
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new CampaignCliError(`${file} is not valid JSON.`);
+  }
+}
+
+function writableForLines(row: CampaignRow): void {
+  if (row.status === "archived") {
+    throw new CampaignCliError(
+      `"${row.name}" is archived, so its personalized lines can't change. Start again from a copy: dench campaign duplicate ${row._id}`,
+    );
+  }
+}
+
+function noLines(row: CampaignRow): CampaignCliError {
+  return new CampaignCliError(
+    `"${row.name}" has no personalized lines. Add them first: dench campaign personalize set ${row._id} --file lines.json`,
+  );
+}
+
+function resolveLineKey(
+  template: LineTemplate | null,
+  reference: string,
+  row: CampaignRow,
+): string {
+  const variables = template?.variables ?? [];
+  if (!variables.length) throw noLines(row);
+  const wanted = normalizedLineKey(reference.replace(/^\{\{\s*|\s*\}\}$/g, ""));
+  const match = variables.find(
+    (variable) =>
+      normalizedLineKey(variable.key) === wanted ||
+      normalizedLineKey(variable.label) === wanted,
+  );
+  if (!match) {
+    throw new CampaignCliError(
+      `"${reference}" is not one of the personalized lines in "${row.name}". Use one of: ${variables.map((variable) => variable.key).join(", ")}.`,
+    );
+  }
+  return match.key;
+}
+
+async function personalizeGet(ctx: CampaignCliContext): Promise<void> {
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign personalize get");
+  const row = await resolveCampaign(ctx, reference);
+  const status = await personalizationStatus(ctx, String(row._id));
+  out(ctx, { sequenceId: row._id, ...status }, linesText(row, status));
+}
+
+async function personalizeSet(ctx: CampaignCliContext): Promise<void> {
+  const file = requiredFlag(ctx.args, "--file");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign personalize set");
+  const parsed = await readJsonFile(file);
+  const row = await resolveCampaign(ctx, reference);
+  writableForLines(row);
+  const status = await personalizationStatus(ctx, String(row._id));
+  let template: LineTemplate;
+  try {
+    template = linesTemplateFromFile(parsed, {
+      existing: status.template,
+      suggestedSells: status.suggestedContext.sells,
+      source: file,
+    });
+  } catch (error) {
+    if (error instanceof LinesFileError)
+      throw new CampaignCliError(error.message);
+    throw error;
+  }
+  const result = (await callMutation(ctx, `${PERSONALIZE}:setTemplate`, {
+    sequenceId: row._id,
+    template,
+  })) as BackfillResult;
+  const keys = template.variables.map((variable) => `{{${variable.key}}}`);
+  out(ctx, { ok: true, sequenceId: row._id, template, ...result }, [
+    `Saved ${plural(template.variables.length, "personalized line", "personalized lines")} on "${row.name}": ${keys.join(", ")}. Put each one in your steps where that line belongs.`,
+    backfillText(row, result),
+  ]);
+}
+
+async function personalizeClear(ctx: CampaignCliContext): Promise<void> {
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign personalize clear");
+  const row = await resolveCampaign(ctx, reference);
+  writableForLines(row);
+  await callMutation(ctx, `${PERSONALIZE}:setTemplate`, {
+    sequenceId: row._id,
+    template: null,
+  });
+  out(ctx, { ok: true, sequenceId: row._id, template: null }, [
+    `Turned off personalized lines on "${row.name}". Lines not yet written were canceled.`,
+  ]);
+}
+
+async function personalizeWrite(ctx: CampaignCliContext): Promise<void> {
+  const all = hasFlag(ctx.args, "--all");
+  const yes = hasFlag(ctx.args, "--yes");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign personalize write");
+  const row = await resolveCampaign(ctx, reference);
+  writableForLines(row);
+  const result = (await callMutation(ctx, `${PERSONALIZE}:backfill`, {
+    sequenceId: row._id,
+    mode: all ? "all" : "missing",
+    ...(yes ? { confirmed: true } : {}),
+  })) as BackfillResult;
+  const payload = {
+    sequenceId: row._id,
+    mode: all ? "all" : "missing",
+    ...result,
+  };
+  if (result.needsConfirm) {
+    out(ctx, payload, [
+      `${all ? "Rewriting" : "Writing"} lines for ${plural(result.eligible, "person", "people")} in "${row.name}" costs about ${formatCents(result.estimatedCents)}. Nothing was written.`,
+    ]);
+    throw new CampaignCliError(
+      `Confirm the cost with: dench campaign personalize write ${row._id}${all ? " --all" : ""} --yes`,
+    );
+  }
+  out(ctx, payload, [backfillText(row, result)]);
+}
+
+async function personalizeEdit(ctx: CampaignCliContext): Promise<void> {
+  const person = requiredFlag(ctx.args, "--person");
+  const line = requiredFlag(ctx.args, "--line");
+  if (!ctx.args.includes("--text")) {
+    throw new CampaignCliError(
+      'Missing required --text "..." (an empty --text "" undoes your edit).',
+    );
+  }
+  const text = valueFlag(ctx.args, "--text") ?? "";
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign personalize edit");
+  const row = await resolveCampaign(ctx, reference);
+  const [status, detail] = await Promise.all([
+    personalizationStatus(ctx, String(row._id)),
+    loadDetail(ctx, String(row._id)),
+  ]);
+  const key = resolveLineKey(status.template, line, row);
+  const enrollment = resolvePerson(detail, person);
+  const name = enrollment.displayName?.trim() || enrollment._id;
+  await callMutation(ctx, `${PERSONALIZE}:updateAiVariable`, {
+    enrollmentId: enrollment._id,
+    key,
+    value: text,
+  });
+  const cleared = !text.trim();
+  out(
+    ctx,
+    {
+      ok: true,
+      sequenceId: row._id,
+      enrollmentId: enrollment._id,
+      key,
+      value: cleared ? null : text.trim(),
+    },
+    [
+      cleared
+        ? `Undid the edit to ${name}'s {{${key}}} in "${row.name}". They get the fallback until a line is written: dench campaign personalize rewrite ${row._id} --person ${enrollment._id} --line ${key}`
+        : `Set ${name}'s {{${key}}} in "${row.name}". Braces are removed and text past the line's length is cut.`,
+    ],
+  );
+}
+
+async function personalizeRewrite(ctx: CampaignCliContext): Promise<void> {
+  const person = requiredFlag(ctx.args, "--person");
+  const line = valueFlag(ctx.args, "--line");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign personalize rewrite");
+  const row = await resolveCampaign(ctx, reference);
+  writableForLines(row);
+  const [status, detail] = await Promise.all([
+    personalizationStatus(ctx, String(row._id)),
+    loadDetail(ctx, String(row._id)),
+  ]);
+  if (!status.template?.variables.length) throw noLines(row);
+  const key =
+    line === undefined ? undefined : resolveLineKey(status.template, line, row);
+  const enrollment = resolvePerson(detail, person);
+  const name = enrollment.displayName?.trim() || enrollment._id;
+  const result = (await callMutation(
+    ctx,
+    `${PERSONALIZE}:rewriteForEnrollment`,
+    { enrollmentId: enrollment._id, ...(key ? { key } : {}) },
+  )) as { queued: boolean };
+  const what = key ? `{{${key}}}` : "lines";
+  out(
+    ctx,
+    {
+      ok: true,
+      sequenceId: row._id,
+      enrollmentId: enrollment._id,
+      ...(key ? { key } : {}),
+      queued: result.queued,
+    },
+    [
+      result.queued
+        ? `Writing new ${what} for ${name} in "${row.name}", about ${formatCents(status.estimatedCentsPerPerson)}. See them with: dench campaign preview ${row._id} --person ${enrollment._id}`
+        : `New ${what} for ${name} are already being written.`,
+    ],
+  );
+}
+
+async function runPersonalize(ctx: CampaignCliContext): Promise<void> {
+  const verb = ctx.args.shift();
+  switch (verb) {
+    case "get":
+    case "show":
+    case "status":
+      return personalizeGet(ctx);
+    case "set":
+      return personalizeSet(ctx);
+    case "clear":
+    case "off":
+      return personalizeClear(ctx);
+    case "write":
+    case "backfill":
+      return personalizeWrite(ctx);
+    case "edit":
+      return personalizeEdit(ctx);
+    case "rewrite":
+      return personalizeRewrite(ctx);
+    default:
+      throw new CampaignCliError(
+        `Use one of:\n  ${PERSONALIZE_USAGE.join("\n  ")}`,
+      );
+  }
+}
+
+async function runSync(ctx: CampaignCliContext): Promise<void> {
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign sync");
+  const row = await resolveCampaign(ctx, reference);
+  if (row.status === "archived" || row.status === "completed") {
+    out(
+      ctx,
+      { ok: true, sequenceId: row._id, status: row.status, updated: 0 },
+      [
+        `"${row.name}" is ${row.status}, so nobody in it can use new contact details. Nothing changed.`,
+      ],
+    );
+    return;
+  }
+  const result = (await callMutation(
+    ctx,
+    `${OUTREACH}:syncEnrollmentsFromRecords`,
+    { sequenceId: row._id },
+  )) as { updated: number };
+  out(
+    ctx,
+    {
+      ok: true,
+      sequenceId: row._id,
+      status: row.status,
+      updated: result.updated,
+    },
+    [
+      result.updated === 0
+        ? `Nobody in "${row.name}" had anything new on their CRM record.`
+        : `Updated ${result.updated} ${result.updated === 1 ? "person" : "people"} in "${row.name}" from their CRM records.`,
+      "Only empty details are filled (email, LinkedIn URL, name and merge fields); nothing already in the campaign is overwritten.",
+    ],
+  );
+}
+
+async function runResumeAll(ctx: CampaignCliContext): Promise<void> {
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign resume-person");
+  const row = await resolveCampaign(ctx, reference);
+  if (row.status !== "active") {
+    throw new CampaignCliError(
+      row.status === "paused"
+        ? `"${row.name}" is paused. Resume the campaign first: dench campaign resume ${row._id}`
+        : `Only people in an active campaign can be resumed. "${row.name}" is ${row.status}.`,
+    );
+  }
+  const result = (await callMutation(
+    ctx,
+    `${OUTREACH}:resumePausedEnrollments`,
+    { sequenceId: row._id },
+  )) as { resumed: number };
+  out(ctx, { ok: true, sequenceId: row._id, resumed: result.resumed }, [
+    result.resumed === 0
+      ? `Nobody in "${row.name}" was paused, so nothing changed.`
+      : `Resumed ${result.resumed} paused ${result.resumed === 1 ? "person" : "people"} in "${row.name}". Their next step is scheduled now.`,
+  ]);
+}
+
+async function runPerson(
+  ctx: CampaignCliContext,
+  action: "stop" | "resume-person",
+): Promise<void> {
+  if (action === "resume-person" && hasFlag(ctx.args, "--all")) {
+    if (ctx.args.includes("--person")) {
+      throw new CampaignCliError(
+        "Pass either --person or --all to resume-person, not both.",
+      );
+    }
+    return runResumeAll(ctx);
+  }
+  if (action === "resume-person" && !ctx.args.includes("--person")) {
+    throw new CampaignCliError(
+      "Missing required --person <enrollmentId|name>, or --all to resume every paused person.",
+    );
+  }
+  const person = requiredFlag(ctx.args, "--person");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, `campaign ${action}`);
+  const row = await resolveCampaign(ctx, reference);
+  const detail = await loadDetail(ctx, String(row._id));
+  const enrollment = resolvePerson(detail, person);
+  const name = enrollment.displayName?.trim() || enrollment._id;
+  if (action === "stop") {
+    if (row.status === "draft" && enrollment.firstContactedAt === undefined) {
+      await removeEnrollment(ctx, enrollment._id);
+      out(
+        ctx,
+        {
+          ok: true,
+          enrollmentId: enrollment._id,
+          status: "removed",
+          changed: true,
+        },
+        [
+          `Removed ${name} from the draft "${row.name}" instead of stopping them: nothing had been sent, and a stopped person would block the launch.`,
+        ],
+      );
+      return;
+    }
+    if (
+      [
+        "finished",
+        "stopped",
+        "replied",
+        "bounced",
+        "complained",
+        "unsubscribed",
+        "failed",
+      ].includes(enrollment.status)
+    ) {
+      out(
+        ctx,
+        {
+          ok: true,
+          enrollmentId: enrollment._id,
+          status: enrollment.status,
+          changed: false,
+        },
+        [`${name} is already ${enrollment.status}; nothing more will be sent.`],
+      );
+      return;
+    }
+    await callMutation(ctx, `${OUTREACH}:stopEnrollment`, {
+      enrollmentId: enrollment._id,
+    });
+    out(
+      ctx,
+      {
+        ok: true,
+        enrollmentId: enrollment._id,
+        status: "stopped",
+        changed: true,
+      },
+      [
+        `Stopped ${name} in "${row.name}". They will get nothing more from this campaign.`,
+      ],
+    );
+    return;
+  }
+  if (enrollment.status !== "paused") {
+    throw new CampaignCliError(
+      `${name} is ${enrollment.status}, not paused. Only a paused person can be resumed.`,
+    );
+  }
+  if (row.status !== "active") {
+    throw new CampaignCliError(
+      `Resume the campaign first: dench campaign resume ${row._id}`,
+    );
+  }
+  await callMutation(ctx, `${OUTREACH}:resumeEnrollment`, {
+    enrollmentId: enrollment._id,
+  });
+  out(
+    ctx,
+    { ok: true, enrollmentId: enrollment._id, status: "active", changed: true },
+    [`Resumed ${name} in "${row.name}".`],
   );
 }
 
@@ -2179,6 +3225,493 @@ type EventRow = {
   stepIndex?: number;
 };
 
+type MessagePreview = {
+  channel: "email" | "linkedin";
+  subject?: string;
+  textBody?: string;
+  htmlBody?: string;
+  messageBody?: string;
+  fromName?: string;
+  fromEmail?: string;
+  toName: string;
+  toEmail?: string;
+  missingFields: string[];
+  warnings: string[];
+  skippedReason?: string;
+  personalized?: Array<{
+    key: string;
+    label: string;
+    value: string;
+    state: string;
+  }>;
+};
+
+const PREVIEW = "functions/outreachMessagePreview";
+
+const LINE_STATE_TEXT: Record<string, string> = {
+  written: "written",
+  edited: "edited by hand",
+  writing: "being written; the fallback shows until then",
+  paused: "waiting for the campaign to resume; the fallback shows until then",
+  fallback: "nothing specific found, so the fallback is used",
+  not_written: "not written yet; the fallback shows until then",
+};
+
+function htmlToText(html: string): string {
+  return html
+    .replace(/<\s*br\s*\/?\s*>/gi, "\n")
+    .replace(/<\/(p|div|h[1-6]|li|tr)>/gi, "\n")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&amp;/g, "&")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function indent(text: string): string[] {
+  return text.split("\n").map((line) => `    ${line}`);
+}
+
+function previewLines(
+  stepNumber: number,
+  step: { type: string; waitHours?: unknown },
+  preview: MessagePreview,
+): string[] {
+  const from =
+    preview.fromName || preview.fromEmail
+      ? ` · from ${preview.fromName ?? ""}${preview.fromEmail ? `${preview.fromName ? " " : ""}<${preview.fromEmail}>` : ""}`
+      : "";
+  const to =
+    preview.channel === "email" && preview.toEmail
+      ? ` to ${preview.toEmail}`
+      : "";
+  const lines = [`Step ${stepNumber} · ${stepLabel(step)}${from}${to}`];
+  if (preview.skippedReason) lines.push(`  skipped: ${preview.skippedReason}`);
+  if (preview.channel === "email") {
+    lines.push(`  Subject: ${preview.subject ?? ""}`);
+    const body = preview.textBody?.trim() || htmlToText(preview.htmlBody ?? "");
+    lines.push(...indent(body || "(empty)"));
+  } else {
+    lines.push(...indent(preview.messageBody?.trim() || "(empty)"));
+  }
+  for (const line of preview.personalized ?? [])
+    lines.push(
+      `  {{${line.key}}} ${line.label}: ${LINE_STATE_TEXT[line.state] ?? line.state}`,
+    );
+  if (preview.missingFields.length)
+    lines.push(
+      `  missing: ${preview.missingFields.map((field) => `{{${field}}}`).join(", ")}`,
+    );
+  for (const warning of preview.warnings) lines.push(`  note: ${warning}`);
+  return lines;
+}
+
+async function runPreview(ctx: CampaignCliContext): Promise<void> {
+  const personRef = valueFlag(ctx.args, "--person");
+  const stepRaw = valueFlag(ctx.args, "--step");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign preview");
+  const row = await resolveCampaign(ctx, reference);
+  const detail = await loadDetail(ctx, String(row._id));
+  const steps = [...detail.steps].sort(
+    (a, b) => (a.order ?? 0) - (b.order ?? 0),
+  );
+  const sendable = steps
+    .map((step, index) => ({ step, number: index + 1 }))
+    .filter(({ step }) => step.type !== "wait");
+  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`,
+    );
+  }
+  let chosen = sendable;
+  if (stepRaw !== undefined) {
+    const number = Number(stepRaw);
+    if (!Number.isInteger(number) || number < 1 || number > steps.length) {
+      throw new CampaignCliError(
+        `--step must be a step number from 1 to ${steps.length} (see dench campaign steps get ${row._id}).`,
+      );
+    }
+    chosen = sendable.filter((entry) => entry.number === number);
+    if (!chosen.length) {
+      throw new CampaignCliError(
+        `Step ${number} is a wait, so it sends nothing. Steps with a message: ${sendable.map((entry) => entry.number).join(", ")}.`,
+      );
+    }
+  }
+  if (!detail.enrollments.length) {
+    throw new CampaignCliError(
+      `Nobody is in "${row.name}" yet, so there is no one to preview for. Add people first: dench campaign add ${row._id} ...`,
+    );
+  }
+  const enrollment = personRef
+    ? resolvePerson(detail, personRef)
+    : detail.enrollments[0];
+  const name = enrollment.displayName?.trim() || enrollment._id;
+  const rendered = await Promise.all(
+    chosen.map(async ({ step, number }) => ({
+      step,
+      number,
+      preview: (await callQuery(ctx, `${PREVIEW}:preview`, {
+        sequenceId: row._id,
+        enrollmentId: enrollment._id,
+        stepId: step._id,
+        stepIndex: step.order ?? number - 1,
+      })) as MessagePreview,
+    })),
+  );
+  const lines = [
+    `What ${name} gets from "${row.name}"${personRef ? "" : " (the first person; pick someone with --person)"}:`,
+  ];
+  for (const { step, number, preview } of rendered)
+    lines.push("", ...previewLines(number, step, preview));
+  out(
+    ctx,
+    {
+      sequenceId: row._id,
+      enrollmentId: enrollment._id,
+      person: name,
+      steps: rendered.map(({ step, number, preview }) => ({
+        step: number,
+        stepId: step._id,
+        type: step.type,
+        ...preview,
+      })),
+    },
+    lines,
+  );
+}
+
+const ACTIVITY = "functions/crm/activity";
+const REPLIES_DEFAULT_LIMIT = 20;
+const REPLIES_MAX_LIMIT = 50;
+const REPLY_LOOKUP_CONCURRENCY = 5;
+
+const CHANNEL_KINDS: Record<string, string[]> = {
+  email: ["email_in", "email_out"],
+  linkedin: ["linkedin_in", "linkedin_out"],
+};
+
+type LedgerThread = {
+  type: string;
+  thread?: { threadKey: string; title?: string };
+};
+
+type LedgerMessage = {
+  kind: string;
+  occurredAt: number;
+  direction?: "inbound" | "outbound";
+  from: string;
+  snippet: string;
+};
+
+type InboundReply = {
+  at: number;
+  channel: "email" | "linkedin";
+  from: string;
+  text: string;
+  subject?: string;
+  answered: boolean;
+};
+
+function parseSince(raw: string): number {
+  const relative = /^(\d+)([hdw])$/i.exec(raw.trim());
+  if (relative) {
+    const unit = relative[2].toLowerCase();
+    const span =
+      unit === "h" ? 3_600_000 : unit === "d" ? 86_400_000 : 604_800_000;
+    return Date.now() - Number(relative[1]) * span;
+  }
+  const parsed = Date.parse(raw);
+  if (Number.isNaN(parsed)) {
+    throw new CampaignCliError(
+      "--since must look like 12h, 7d, 2w or a date such as 2026-09-01",
+    );
+  }
+  return parsed;
+}
+
+async function latestInbound(
+  ctx: CampaignCliContext,
+  places: ReadonlyArray<{ entryId: string; objectName: string }>,
+  channel: string | undefined,
+): Promise<InboundReply | null> {
+  let best: InboundReply | null = null;
+  for (const place of places) {
+    let feed: { items?: LedgerThread[] };
+    try {
+      feed = (await callQuery(ctx, `${ACTIVITY}:listForEntry`, {
+        objectName: place.objectName,
+        entryId: place.entryId,
+        order: "desc",
+        limit: 3,
+        kinds: (channel && CHANNEL_KINDS[channel]) || [
+          ...CHANNEL_KINDS.email,
+          ...CHANNEL_KINDS.linkedin,
+        ],
+      })) as { items?: LedgerThread[] };
+    } catch {
+      continue;
+    }
+    for (const item of feed.items ?? []) {
+      if (item.type !== "thread" || !item.thread) continue;
+      let messages: LedgerMessage[];
+      try {
+        messages = (await callQuery(ctx, `${ACTIVITY}:listThreadMessages`, {
+          objectName: place.objectName,
+          entryId: place.entryId,
+          threadKey: item.thread.threadKey,
+          limit: 20,
+        })) as LedgerMessage[];
+      } catch {
+        continue;
+      }
+      const inbound = [...messages]
+        .reverse()
+        .find((message) => message.direction === "inbound");
+      if (!inbound || (best && inbound.occurredAt <= best.at)) continue;
+      best = {
+        at: inbound.occurredAt,
+        channel: inbound.kind.startsWith("linkedin") ? "linkedin" : "email",
+        from: inbound.from,
+        text: inbound.snippet,
+        ...(item.thread.title ? { subject: item.thread.title } : {}),
+        answered: messages.some(
+          (message) =>
+            message.direction === "outbound" &&
+            message.occurredAt > inbound.occurredAt,
+        ),
+      };
+    }
+  }
+  return best;
+}
+
+async function runReplies(ctx: CampaignCliContext): Promise<void> {
+  const limitRaw = valueFlag(ctx.args, "--limit");
+  const sinceRaw = valueFlag(ctx.args, "--since");
+  const personRef = valueFlag(ctx.args, "--person");
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign replies");
+  const limit =
+    limitRaw === undefined ? REPLIES_DEFAULT_LIMIT : Number(limitRaw);
+  if (!Number.isInteger(limit) || limit < 1 || limit > REPLIES_MAX_LIMIT) {
+    throw new CampaignCliError(
+      `--limit must be a whole number from 1 to ${REPLIES_MAX_LIMIT}`,
+    );
+  }
+  const since = sinceRaw === undefined ? undefined : parseSince(sinceRaw);
+  const row = await resolveCampaign(ctx, reference);
+  const detail = await loadDetail(ctx, String(row._id));
+  const only = personRef ? resolvePerson(detail, personRef) : null;
+  const replied = detail.enrollments
+    .filter(
+      (enrollment) =>
+        (enrollment.status === "replied" || enrollment.repliedAt != null) &&
+        (!only || enrollment._id === only._id) &&
+        (since === undefined || (enrollment.repliedAt ?? 0) >= since),
+    )
+    .sort((a, b) => (b.repliedAt ?? 0) - (a.repliedAt ?? 0));
+  const shown = replied.slice(0, limit);
+  const people: Array<{
+    enrollment: Enrollment;
+    name: string;
+    reply: InboundReply | null;
+  }> = [];
+  for (let start = 0; start < shown.length; start += REPLY_LOOKUP_CONCURRENCY) {
+    people.push(
+      ...(await Promise.all(
+        shown
+          .slice(start, start + REPLY_LOOKUP_CONCURRENCY)
+          .map(async (enrollment) => {
+            const connected = detail.connectedEntries?.[String(enrollment._id)];
+            const places = [
+              connected
+                ? {
+                    entryId: connected.entryId,
+                    objectName: connected.objectName,
+                  }
+                : null,
+              connected?.lead
+                ? { entryId: connected.lead.entryId, objectName: "lead" }
+                : null,
+            ].filter(
+              (
+                place,
+                index,
+                all,
+              ): place is {
+                entryId: string;
+                objectName: string;
+              } =>
+                place !== null &&
+                all.findIndex((other) => other?.entryId === place.entryId) ===
+                  index,
+            );
+            return {
+              enrollment,
+              name:
+                enrollment.displayName?.trim() ||
+                connected?.label ||
+                enrollment._id,
+              reply: await latestInbound(
+                ctx,
+                places,
+                enrollment.repliedChannel,
+              ),
+            };
+          }),
+      )),
+    );
+  }
+  const header = `${replied.length} ${replied.length === 1 ? "person" : "people"} replied to "${row.name}"${since !== undefined ? ` since ${fmtWhen(since)}` : ""}${replied.length > shown.length ? ` (showing the newest ${shown.length}; raise --limit, up to ${REPLIES_MAX_LIMIT})` : replied.length ? " (newest first)" : ""}`;
+  const lines = [header];
+  for (const { enrollment, name, reply } of people) {
+    const connected = detail.connectedEntries?.[String(enrollment._id)];
+    const bits = [
+      `replied${enrollment.repliedChannel ? ` by ${enrollment.repliedChannel}` : ""}${enrollment.repliedAt ? ` ${fmtRelative(enrollment.repliedAt)}` : ""}`,
+    ];
+    if (connected?.lead?.status) bits.push(`lead: ${connected.lead.status}`);
+    if (reply && !reply.answered) bits.push("not answered yet");
+    lines.push(`  ${name}  —  ${bits.join(" · ")}  [${enrollment._id}]`);
+    if (reply) {
+      lines.push(
+        ...reply.text.split("\n").map((line) => `      ${line}`),
+        `      — ${reply.channel}${reply.subject ? `, "${reply.subject}"` : ""}, ${fmtWhen(reply.at)}`,
+      );
+    } else {
+      lines.push(
+        "      (the message text is not in the activity ledger yet; dench crm activity <object> <entryId> shows what has arrived)",
+      );
+    }
+  }
+  out(
+    ctx,
+    {
+      sequenceId: row._id,
+      count: replied.length,
+      shown: shown.length,
+      replies: people.map(({ enrollment, name, reply }) => {
+        const connected = detail.connectedEntries?.[String(enrollment._id)];
+        return {
+          enrollmentId: enrollment._id,
+          name,
+          status: enrollment.status,
+          repliedAt: enrollment.repliedAt ?? null,
+          repliedChannel: enrollment.repliedChannel ?? null,
+          lead: connected?.lead ?? null,
+          record: connected
+            ? { entryId: connected.entryId, objectName: connected.objectName }
+            : null,
+          reply,
+        };
+      }),
+    },
+    lines,
+  );
+}
+
+type Membership = {
+  enrollment: {
+    _id: string;
+    sequenceId: string;
+    displayName?: string;
+    status: string;
+    currentStepIndex?: number;
+    repliedAt?: number;
+  };
+  sequenceName: string;
+  isOwner?: boolean;
+  senders?: {
+    email?: { label: string; status: string } | null;
+    linkedin?: { label: string; status: string } | null;
+  };
+};
+
+async function runWhere(ctx: CampaignCliContext): Promise<void> {
+  const entryId = shift(ctx.args, "CRM record id");
+  unknownFlags(ctx.args, "campaign where");
+  const memberships = (await callQuery(
+    ctx,
+    `${OUTREACH}:listEnrollmentsForEntry`,
+    { entryId },
+  )) as Membership[];
+  const lines = [
+    memberships.length
+      ? `This record is in ${memberships.length} ${memberships.length === 1 ? "campaign" : "campaigns"} (newest first):`
+      : "This record is not in any campaign.",
+  ];
+  for (const { enrollment, sequenceName, senders } of memberships) {
+    const bits = [enrollment.status];
+    if (typeof enrollment.currentStepIndex === "number")
+      bits.push(`step ${enrollment.currentStepIndex + 1}`);
+    if (enrollment.repliedAt) bits.push("replied");
+    const from = [senders?.email?.label, senders?.linkedin?.label].filter(
+      Boolean,
+    );
+    if (from.length) bits.push(`sent from ${from.join(" + ")}`);
+    lines.push(
+      `  ${sequenceName}  —  ${bits.join(" · ")}  [${enrollment.sequenceId}, person ${enrollment._id}]`,
+    );
+  }
+  out(
+    ctx,
+    {
+      entryId,
+      count: memberships.length,
+      campaigns: memberships.map(({ enrollment, sequenceName, senders }) => ({
+        sequenceId: enrollment.sequenceId,
+        name: sequenceName,
+        enrollmentId: enrollment._id,
+        status: enrollment.status,
+        currentStepIndex: enrollment.currentStepIndex ?? null,
+        repliedAt: enrollment.repliedAt ?? null,
+        senders: senders ?? null,
+      })),
+    },
+    lines,
+  );
+}
+
+type PipelineCounts = {
+  total: number;
+  statuses: Array<{ name: string; color: string; count: number }>;
+  other: number;
+};
+
+async function runPipeline(ctx: CampaignCliContext): Promise<void> {
+  const reference = shift(ctx.args, "campaign id or name");
+  unknownFlags(ctx.args, "campaign pipeline");
+  const row = await resolveCampaign(ctx, reference);
+  const counts = (await callQuery(
+    ctx,
+    `${OUTREACH}:getSequenceLeadStatusCounts`,
+    {
+      sequenceId: row._id,
+    },
+  )) as PipelineCounts | null;
+  if (!counts) throw new CampaignCliError("Campaign not found");
+  const width = Math.max(
+    5,
+    ...counts.statuses.map((status) => status.name.length),
+  );
+  const lines = [
+    `Where ${counts.total} ${counts.total === 1 ? "person" : "people"} in "${row.name}" stand in the lead pipeline:`,
+    ...counts.statuses.map(
+      (status) => `  ${status.name.padEnd(width)}  ${status.count}`,
+    ),
+  ];
+  if (counts.other > 0)
+    lines.push(
+      `  ${"other".padEnd(width)}  ${counts.other}  (no lead, or a status outside the pipeline)`,
+    );
+  out(ctx, { sequenceId: row._id, ...counts }, lines);
+}
+
 async function runEvents(ctx: CampaignCliContext): Promise<void> {
   const limitRaw = valueFlag(ctx.args, "--limit");
   const maxPagesRaw = valueFlag(ctx.args, "--max-pages");
@@ -2249,8 +3782,32 @@ type MailboxRow = {
   isOwner?: boolean;
   visibility?: string;
   remainingToday?: number;
+  warmupStatus?: string;
+  readyAt?: number;
+  dailyColdSendCap?: number;
+};
+
+const WARMUP_TEXT: Record<string, string> = {
+  ready: "warm-up done",
+  skipped: "warm-up skipped",
+  warming: "warming up",
+  pending_auth: "warm-up waiting for the owner to finish connecting it",
+  error: "warm-up needs the owner's attention",
 };
 
+function describeWarmup(mailbox: {
+  warmupStatus: string | null;
+  readyAt: number | null;
+}): string | null {
+  if (!mailbox.warmupStatus) return null;
+  const text =
+    WARMUP_TEXT[mailbox.warmupStatus] ??
+    mailbox.warmupStatus.replace(/_/g, " ");
+  return mailbox.warmupStatus === "warming" && mailbox.readyAt
+    ? `${text} until ${fmtWhen(mailbox.readyAt)}`
+    : text;
+}
+
 type LinkedinSenderRow = {
   linkedinAccountId: string;
   displayName?: string;
@@ -2291,6 +3848,9 @@ async function runAccounts(ctx: CampaignCliContext): Promise<void> {
       isOwner: row.isOwner === true,
       visibility: row.visibility ?? null,
       remainingToday: remainingCapacity(row.remainingToday),
+      dailyColdSendCap: remainingCapacity(row.dailyColdSendCap),
+      warmupStatus: row.warmupStatus ?? null,
+      readyAt: typeof row.readyAt === "number" ? row.readyAt : null,
     }),
   );
   // An allowlist on the client as well as the query's return validator keeps
@@ -2314,10 +3874,10 @@ async function runAccounts(ctx: CampaignCliContext): Promise<void> {
   }));
   const lines = [
     `Mailboxes (${mailboxes.length}) — use these ids with --email-mailboxes:`,
-    ...mailboxes.map(
-      (m) =>
-        `  ${m.email ?? "(no address)"}  —  ${m.provider ?? "mailbox"} · ${m.status ?? "unknown"}${m.statusReason ? ` (${m.statusReason})` : ""}${m.remainingToday === null ? "" : ` · ${m.remainingToday} remaining today`}${m.ownerName && !m.isOwner ? ` · ${m.ownerName}` : ""}${m.visibility === "private" ? " · private" : ""}  [${m.emailMailboxAccountId}]`,
-    ),
+    ...mailboxes.map((m) => {
+      const warmup = describeWarmup(m);
+      return `  ${m.email ?? "(no address)"}  —  ${m.provider ?? "mailbox"} · ${m.status ?? "unknown"}${m.statusReason ? ` (${m.statusReason})` : ""}${warmup ? ` · ${warmup}` : ""}${m.remainingToday === null ? "" : ` · ${m.remainingToday}${m.dailyColdSendCap === null ? "" : ` of ${m.dailyColdSendCap}`} cold emails left today`}${m.ownerName && !m.isOwner ? ` · ${m.ownerName}` : ""}${m.visibility === "private" ? " · private" : ""}  [${m.emailMailboxAccountId}]`;
+    }),
   ];
   if (mailboxes.length === 0) {
     lines.push(
@@ -2340,7 +3900,7 @@ async function runAccounts(ctx: CampaignCliContext): Promise<void> {
     );
   }
   const note =
-    "Capacity is a usage snapshot before queued work and campaign limits. Pool changes require access for both you and the campaign owner; launch and dispatch revalidate availability.";
+    "Capacity is a usage snapshot before queued work and campaign limits. A mailbox's daily cap and warm-up, and a LinkedIn account's limits and hours, are set by its owner in the Dench app. Pool changes require access for both you and the campaign owner; launch and dispatch revalidate availability.";
   lines.push("", note);
   out(
     ctx,
@@ -2366,6 +3926,13 @@ const SUBCOMMAND_ALIASES: Record<string, string> = {
   start: "launch",
   activity: "events",
   senders: "accounts",
+  delete: "archive",
+  copy: "duplicate",
+  clone: "duplicate",
+  memberships: "where",
+  personalization: "personalize",
+  lines: "personalize",
+  variables: "personalize",
 };
 
 export function campaignHelp(subcommand?: string): void {
@@ -2398,12 +3965,31 @@ function campaignHelpText(): string {
 Outreach campaigns send email and LinkedIn steps to a list of people on one
 schedule. <campaign> is an id or an exact (case-insensitive) name.
 
+Start here (references/CAMPAIGNS.md has the full recipe, from a brief to launch):
+  1. dench campaign accounts                       sender ids: mailboxes and LinkedIn accounts
+  2. dench campaign draft --name "..." --timezone <tz> [--email-mailboxes ..] [--linkedin-accounts ..]
+  3. dench campaign search --filters @filters.json --not-industries "..." --limit 25 --out audience.json
+  4. dench campaign add <campaign> --people-file audience.json
+  5. dench campaign steps set <campaign> --file steps.json, then dench campaign preview <campaign>
+  6. dench campaign launch <campaign> --check, then launch once the user says yes
+
 Browse:
   dench campaign list [--all]                       # live campaigns; --all includes archived
   dench campaign get <campaign>                     # status, schedule, funnel, Now/Next, holds, people
   dench campaign people <campaign> [--status active|paused|finished|replied|stopped|bounced|failed|draft|complained|unsubscribed]
   dench campaign events <campaign> [--limit 50] [--max-pages 1]   # activity log, newest first
-  dench campaign accounts                           # email + LinkedIn sender ids, availability and capacity
+  dench campaign preview <campaign> [--person <enrollmentId|name>] [--step N]   # the exact messages one person gets
+      Renders every email and LinkedIn step (or step N) with their fields and personalized lines filled in, and
+      says what is missing or would be skipped. Nothing is sent. Without --person it uses the first person.
+  dench campaign person show <campaign> --person <enrollmentId|name>   # what the campaign did for one person, step by step
+      Each step with its outcome (sent, opened, clicked, skipped and why, waiting, failed), when it happened, and the
+      subject and start of the text that was sent. Read-only.
+  dench campaign replies <campaign> [--person <enrollmentId|name>] [--since 7d] [--limit 20]   # who replied, with their latest reply
+      Lists the people who replied, newest first, with the text of their latest inbound email or LinkedIn message
+      (up to 400 characters, quoted history removed) and whether you have answered. Read-only.
+  dench campaign pipeline <campaign>                # how many of its people are at each lead Status (New, Contacted, Replied, ...)
+  dench campaign where <entryId>                    # the campaigns a CRM record (person or lead) is in, and its status in each
+  dench campaign accounts                           # email + LinkedIn sender ids, warm-up, availability and capacity
 
 Create and configure:
   dench campaign create --name "Founder outreach" [--timezone America/Los_Angeles] \\
@@ -2413,22 +3999,109 @@ Create and configure:
   dench campaign set <campaign> [--name "New name"] [--timezone <tz>] [--window "<spec>" ...] \\
       [--email-mailboxes id1,id2|none] [--linkedin-accounts id1,id2|none] \\
       [--daily-cap 1-100] [--stop-on-reply|--no-stop-on-reply] [--start <ISO>|--clear-start] [--end <ISO>|--clear-end]
-  dench campaign steps get <campaign>               # prints steps as JSON you can edit
-  dench campaign steps set <campaign> --file steps.json      # replaces every step; drafts only
+  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
+  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.
 
 Fill it:
+  dench campaign draft [--name "New campaign"] [--request-id <8-64 char stable id>] [--timezone <tz>] \\
+      [--window "Mon-Fri 9-18" ...] [--daily-cap 30] [--email-mailboxes id1,id2|none] [--linkedin-accounts id1,id2|none] \\
+      [--stop-on-reply|--no-stop-on-reply] [--start <ISO>] [--end <ISO>]   # same settings as create; a retry returns the same draft
+  dench campaign search [<campaign>] --filters '{"titles":["Founder"]}' [--titles Founder,CEO] [--limit 50] [--page-token <token>] \\
+      [--out audience.json [--force]] [--raw]
+  dench campaign add <campaign> --search '{"titles":["Founder"],"locations":["United States"]}' [--limit 50] [--preview] [--allow-duplicates] [--allow-active]
+  dench campaign add <campaign> --titles Founder --locations "United States" [--headcount 11-50] [--limit 50] [--page-token <token>] [--allow-active] \\
+      [--out added.json [--force]] [--raw]
+  dench campaign add <campaign> --people-file audience.json [--allow-duplicates]
+  dench campaign add <campaign> --csv people.csv [--map "email=Work Email" ...] [--preview] [--allow-duplicates]
+      Reads a spreadsheet export the way the app's Add people does: the email and LinkedIn columns are found from
+      what they hold, whatever they are called; the name comes from First name + Last name columns or from one
+      Name, Full name or Contact column, found by its header; every other column becomes a merge value
+      ({{Company}}, {{Job Title}}). --map email|linkedin|name|first|last="<header or column letter>" overrides a
+      guess (none switches a field off). --preview shows how each column is read and adds nobody. Comma,
+      semicolon and tab files work, up to 500 people.
+  dench campaign add <campaign> --list <artifactId> [--limit 100] [--enrichment enriched] [--preview] [--allow-duplicates]
+      Adds people from a saved list (dench lists; made by dench leads find --save-as) without searching or paying
+      again: new people become Leads during enrollment, with custom variables preserved. --enrichment keeps only rows at that stage
+      (all, enriched, in_progress, no_contacts, failed, not_enriched); --preview shows the rows and adds nobody.
   dench campaign add <campaign> --object lead --view "Q3 targets" [--email-field Email] [--linkedin-field "POC LinkedIn URL"] \\
       [--name-field Name] [--allow-duplicates]
   dench campaign add <campaign> --object people --entries id1,id2 [--relation-field Contact] [--reverse]
   dench campaign add <campaign> [--name "Ada Lovelace"] --email ada@x.com and/or --linkedin-url https://linkedin.com/in/ada
 
+Personalized lines (written by AI for each person, about 3 cents a person; up to 5 per campaign):
+  dench campaign personalize get <campaign>                   # the lines, their {{keys}}, and how many are written
+  dench campaign personalize set <campaign> --file lines.json  # {"sells":"...","lines":[{"label":"Company hook","instructions":"...","fallback":"..."}]}
+      Optional per line: key (else made from the label), maxChars 20-300, fallbackFrom (a field to use before the fallback).
+      Saving writes lines for up to 100 people right away; more waits for personalize write --yes. Use each as {{key}} in steps.
+  dench campaign personalize write <campaign> [--all] [--yes]    # write missing lines (--all rewrites everyone); --yes confirms the cost
+  dench campaign personalize edit <campaign> --person <enrollmentId|name> --line <key> --text "..."   # your own text; --text "" undoes it
+  dench campaign personalize rewrite <campaign> --person <enrollmentId|name> [--line <key>]   # a fresh line for one person
+  dench campaign personalize clear <campaign>                 # turn lines off (take the {{keys}} out of the steps first)
+
+Signal builder and sources:
+  dench campaign builder profile
+  dench campaign builder save --file draft.json
+  dench campaign builder get <draftId>
+  dench campaign builder build <draftId>
+  dench campaign builder create <draftId> [--name "New campaign"] [--timezone <tz>]
+  dench campaign builder opener <draftId> <leadId> --text "Opening line"
+  dench campaign builder autofill --description "VP Sales at US software companies"
+  dench campaign builder terms --file targeting.json
+  dench campaign builder estimate --file estimate.json
+  dench campaign sources get <campaign>
+  dench campaign sources signals <campaign>
+  dench campaign sources set <campaign> --data '{"cadence":"weekly"}'
+  dench campaign sources preview <campaign> --signal hiring
+
+--filters and --search take the same JSON with every people filter (@file.json
+works) on both search and add. The dench leads find filter flags (--titles,
+--locations, --industries, --seniorities, --headcount, --functions,
+--company-domains, --company-names, --company-keywords, --profile-keywords,
+--skills, --years-in-role, --exact, ...) add to it: list flags append to the
+JSON lists, so {"value":"Staffing and Recruiting","exclude":true} exclusions
+stay. Leave values out with --not-<flag> on any list flag (--exclude-<flag>
+works too), e.g. --not-industries "Staffing and Recruiting" --not-company-keywords
+agency --not-domains example.com; each value is sent as {"value":"...","exclude":true},
+and a search still needs at least one include filter. Names with a comma that
+match a known value stay whole; any other comma splits a value in two, so wrap a
+value that contains one in double quotes inside the shell quotes
+(--titles '"Vice President, Information Systems"') or use --filters JSON. A Note
+on stderr shows how a value was split (not for domains or exact filter values).
+--limit is at most 100 for search and 50 per add; continue with --page-token.
+Search and --preview cost 1 cent per person returned; preview means no enrollment, not
+free search. The most a call can cost prints on stderr before it runs, and results
+carry estimatedCents and chargedCents. Output lists each person once (rows and
+recipients) with nextPageToken on top; --raw adds the raw people records and
+--out <file> writes the full result to a file you can pass to --people-file.
+--out is checked before anything is billed: its folder must exist and the file
+must not (--force replaces it, so give each page its own name). If it still
+cannot be written, the result prints on stdout and is not lost.
+--people-file accepts a recipient array or the JSON response from campaign search.
+It adds already-fetched people without another search. Searching and adding never
+launch a campaign: run launch --check, then launch once the user says yes.
+Adding people to a launched campaign starts their steps; a search add into a
+campaign that is not a draft needs --allow-active. Every add result has campaignStatus.
+
 Run it:
-  dench campaign launch <campaign> [--ack-linkedin-risk]     # checks readiness first; prints blockers
+  dench campaign launch <campaign> --check                   # readiness only, never launches: blockers with why + fix, warnings, fingerprint; exit 1 when blocked
+  dench campaign launch <campaign> [--ack-linkedin-risk]     # launches as soon as it is ready (real messages go out); prints blockers otherwise; start is the same command
   dench campaign pause <campaign>
   dench campaign resume <campaign>
   dench campaign archive <campaign>                 # stops everyone still in flight
-  dench campaign stop <campaign> --person <enrollmentId|name>
-  dench campaign resume-person <campaign> --person <enrollmentId|name>
+      dench campaign delete is the same command: like Delete in the app, it archives (nothing is erased; leads and activity stay)
+  dench campaign stop <campaign> --person <enrollmentId|name>     # nothing more is sent; in a draft, a never-contacted person is removed instead
+  dench campaign remove <campaign> --person <enrollmentId|name>   # drafts only: drop someone never contacted, freeing their place
+  dench campaign resume-person <campaign> --person <enrollmentId|name> | --all   # --all: every paused person, e.g. after a reconnect
+  dench campaign person set <campaign> --person <enrollmentId|name> [--email ada@new.com] [--linkedin-url <url>] \\
+      [--field "Job Title=CTO" ...]   # before launch: fix an address or fill a {{merge field}}; --field repeats
+  dench campaign sync <campaign>                    # fill people's empty email, LinkedIn URL, name and fields from their CRM records
 
 Send window spec (--window, repeatable, all in --timezone):
   "Mon-Fri 9-18"  "Mon,Wed,Fri 10-16"  "Weekdays 9am-5pm"  "Sat-Sun 10-14"
@@ -2437,7 +4110,27 @@ 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. See references/CAMPAIGNS.md for every field.
+linkedin_connection, linkedin_message, linkedin_like_post, linkedin_inmail.
+See references/CAMPAIGNS.md for every field.
+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.
+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
+means no automatic withdrawal. Only invitations sent by the campaign are withdrawn.
+Message acceptance waits: connectionTimeoutHours = 1-2160 (default 720), only
+with linkedinMessageMode=wait_until_connected (the default after a connection).
+steps set refuses a field the step type would drop (onlyIf off email/post-like, a body on
+a visit, a reply-in-thread first email), a missing subject or body, a note over
+300, message over 3000 or InMail over 1900 characters, out-of-range step settings,
+a wait of 0 or over 2160 hours, and {TOKEN}
+single braces, which would go out as typed (use {{TOKEN}}; --allow-single-braces
+keeps literal braces). It warns when several LinkedIn messages after a
+connection request each wait 30 days for the accept. An email with both
+emailHtmlBody and emailTextBody sends the HTML, so when you edit only the
+text, the HTML copied from steps get is dropped (with a warning) and the
+new text is sent.
 
 Sender pools: --email-mailboxes and --linkedin-accounts select accounts once for
 the campaign (emailMailboxAccountIds / linkedinAccountIds in the API). Accepts
@@ -2447,8 +4140,8 @@ can be selected. Launch checks availability. A person's sender stays fixed for
 their conversation. Legacy step senders are preserved until a pool is configured.
 
 A campaign holds at most ${MAX_CAMPAIGN_PEOPLE} people. steps set only works on drafts. After
-launch, edit a step's text or wait time in the Dench app; the schedule,
-daily cap and stop-on-reply stay editable here. Leads move New → Contacted → Replied
+launch, change a step's text or wait time with steps edit; the schedule,
+daily cap and stop-on-reply stay editable with set. Leads move New → Contacted → Replied
 on their own as steps go out.
 
 Auth: a workspace member's credentials (dench signin, a member DENCH_API_KEY, or
@@ -2458,11 +4151,23 @@ an agent session). An organization-only key cannot run outreach.
 
 // ─── Entry point ──────────────────────────────────────────────────────────
 
+async function runAgentCommand(ctx: CampaignCliContext, command: string) {
+  const { runCampaignAgentCommand } = await import("./lib/campaign-agent");
+  return runCampaignAgentCommand(
+    {
+      ...ctx,
+      resolveCampaign: (reference) => resolveCampaign(ctx, reference),
+    },
+    command,
+  );
+}
+
 export async function runCampaignCommand(opts: {
   convex: ConvexHttpClient;
   args: string[];
   sessionToken?: string;
   jsonOutput?: boolean;
+  host?: string;
 }): Promise<void> {
   const args = [...opts.args];
   const jsonOutput = hasFlag(args, "--json") || opts.jsonOutput === true;
@@ -2471,6 +4176,7 @@ export async function runCampaignCommand(opts: {
     args,
     jsonOutput,
     sessionToken: opts.sessionToken,
+    host: opts.host,
   };
   const subcommand = args.shift();
   if (
@@ -2487,12 +4193,21 @@ export async function runCampaignCommand(opts: {
     return;
   }
   switch (subcommand) {
+    case "draft":
+    case "search":
+    case "sources":
+    case "builder":
+      return runAgentCommand(ctx, subcommand);
     case "list":
     case "ls":
       return await runList(ctx);
     case "create":
     case "new":
       return await runCreate(ctx);
+    case "duplicate":
+    case "copy":
+    case "clone":
+      return await runDuplicate(ctx);
     case "get":
     case "status":
     case "show":
@@ -2515,12 +4230,34 @@ export async function runCampaignCommand(opts: {
       return await runLifecycle(ctx, "resume");
     case "archive":
       return await runLifecycle(ctx, "archive");
+    case "delete":
+      return await runLifecycle(ctx, "archive", "delete");
     case "people":
       return await runPeople(ctx);
     case "stop":
       return await runPerson(ctx, "stop");
+    case "remove":
+      return await runRemove(ctx);
     case "resume-person":
       return await runPerson(ctx, "resume-person");
+    case "person":
+      return await runPersonCommand(ctx);
+    case "sync":
+      return await runSync(ctx);
+    case "personalize":
+    case "personalization":
+    case "lines":
+    case "variables":
+      return await runPersonalize(ctx);
+    case "preview":
+      return await runPreview(ctx);
+    case "replies":
+      return await runReplies(ctx);
+    case "pipeline":
+      return await runPipeline(ctx);
+    case "where":
+    case "memberships":
+      return await runWhere(ctx);
     case "events":
     case "activity":
       return await runEvents(ctx);
@@ -2529,7 +4266,7 @@ export async function runCampaignCommand(opts: {
       return await runAccounts(ctx);
     default:
       throw new CampaignCliError(
-        `Unknown campaign subcommand: ${subcommand}. Run 'dench campaign help'.`,
+        unknownSubcommandMessage(subcommand, await cliVersion()),
       );
   }
 }