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

package/app-sdk.d.ts

@@ -12,6 +12,443 @@
 // ── Operation request/response types (from cli/lib/api-schemas.ts) ──────
 
 export interface ApiRequests {
+  /** Create an idempotent empty campaign draft with the caller's available sender pools. Does not launch or send. — `dench campaign draft` — POST /api/v1/campaigns/drafts */
+  "campaigns.drafts.create": {
+    /** Your stable id for this request, 8-64 characters. Retrying with the same id returns the same draft instead of creating another. */
+    clientRequestId: string;
+    name?: string;
+    /** IANA timezone, e.g. America/Los_Angeles. Sets a Mon-Fri 9-18 send window in it; without one the draft has no send window. */
+    timezone?: string;
+  };
+  /** Search people by filters without adding CRM records or campaign recipients. Search credits apply; this is not a free provider preview. — `dench campaign search` — POST /api/v1/campaigns/audience/search */
+  "campaigns.audience.search": {
+    sequenceId?: string;
+    filters: {
+      linkedinUrl?: string;
+      fullName?: string;
+      firstName?: string;
+      lastName?: string;
+      /** Current-title text only. For profile or work descriptions, use profileKeywords. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      keywords?: string;
+      companyDomain?: string;
+      companyName?: string;
+      /** Current job titles (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      titles?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Past job titles (free text). */
+      pastTitles?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      personNames?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Seniority in any past role, independent of pastCompanyNames/pastTitles. Current seniority vocabulary plus Founding Team. Founder includes Co-Founder; C-level and Founding Team do not imply founder. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      pastSeniorities?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Text in headline/about or any current/past work description. OR includes, global exclusions. Always loose text matching; missing evidence does not match. */
+      profileKeywords?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Current employer business focus/model (e.g. SaaS, B2B, Cloud), from description/tagline/business tags; distinct from legal companyTypes. Same employer as other current-job filters. Always loose text matching. May need another filter to retrieve candidates. */
+      companyKeywords?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum: Owner, Founder, C-level, Partner, VP, Head, Director, Manager, Senior. */
+      seniorities?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum, e.g. Sales, Marketing, Software. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      jobFunctions?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum, e.g. SDR/BDR, Demand Generation. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      subFunctions?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum, e.g. Software Development. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      industries?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Person locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      locations?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+. */
+      headcountRanges?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      companyNames?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      pastCompanyNames?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      companyDomains?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Company HQ locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      companyHeadquarters?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum: Partnership, Nonprofit, Educational, Privately Held, Public Company, Self-Owned, Self-Employed, Government Agency. */
+      companyTypes?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Universities attended (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      universities?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Profile skills (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      skills?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Spoken languages, e.g. English, German. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      languages?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      yearsInRole?: {
+        min?: number;
+        max?: number;
+      };
+      yearsAtCompany?: {
+        min?: number;
+        max?: number;
+      };
+      daysSinceJobChange?: {
+        min?: number;
+        max?: number;
+      };
+      /** Company founded-year range, e.g. {min: 2015, max: 2024}. */
+      foundedYears?: {
+        min?: number;
+        max?: number;
+      };
+      /** Match free-text filters as whole strings. Default false: titles ['Founder'] also returns 'Co-Founder' and 'Founder & CEO'. Set true to narrow. Domains, LinkedIn URLs, enum filters and numeric ranges are always exact; keywords is always a loose text probe. */
+      exactMatch?: boolean;
+      preferCache?: boolean;
+    };
+    limit?: number;
+    pageToken?: string;
+  };
+  /** Search and add up to 50 people to an existing campaign. New identities become Leads. Search credits apply; use nextPageToken for another page. — `dench campaign add --search` — POST /api/v1/campaigns/{sequenceId}/people/search */
+  "campaigns.people.addFromSearch": {
+    sequenceId: string;
+    filters: {
+      linkedinUrl?: string;
+      fullName?: string;
+      firstName?: string;
+      lastName?: string;
+      /** Current-title text only. For profile or work descriptions, use profileKeywords. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      keywords?: string;
+      companyDomain?: string;
+      companyName?: string;
+      /** Current job titles (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      titles?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Past job titles (free text). */
+      pastTitles?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      personNames?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Seniority in any past role, independent of pastCompanyNames/pastTitles. Current seniority vocabulary plus Founding Team. Founder includes Co-Founder; C-level and Founding Team do not imply founder. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      pastSeniorities?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Text in headline/about or any current/past work description. OR includes, global exclusions. Always loose text matching; missing evidence does not match. */
+      profileKeywords?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Current employer business focus/model (e.g. SaaS, B2B, Cloud), from description/tagline/business tags; distinct from legal companyTypes. Same employer as other current-job filters. Always loose text matching. May need another filter to retrieve candidates. */
+      companyKeywords?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum: Owner, Founder, C-level, Partner, VP, Head, Director, Manager, Senior. */
+      seniorities?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum, e.g. Sales, Marketing, Software. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      jobFunctions?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum, e.g. SDR/BDR, Demand Generation. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      subFunctions?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum, e.g. Software Development. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      industries?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Person locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      locations?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact buckets: 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10001+. */
+      headcountRanges?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      companyNames?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      pastCompanyNames?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      companyDomains?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Company HQ locations — cities, states, countries, or metros (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      companyHeadquarters?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Exact enum: Partnership, Nonprofit, Educational, Privately Held, Public Company, Self-Owned, Self-Employed, Government Agency. */
+      companyTypes?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Universities attended (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      universities?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Profile skills (free text). Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      skills?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      /** Spoken languages, e.g. English, German. Accepted values: see `dench leads filters` or https://dench.com/references/find-filter-options.json. */
+      languages?: Array<string | {
+        value: string;
+        exclude?: boolean;
+        exactMatch?: boolean;
+      }>;
+      yearsInRole?: {
+        min?: number;
+        max?: number;
+      };
+      yearsAtCompany?: {
+        min?: number;
+        max?: number;
+      };
+      daysSinceJobChange?: {
+        min?: number;
+        max?: number;
+      };
+      /** Company founded-year range, e.g. {min: 2015, max: 2024}. */
+      foundedYears?: {
+        min?: number;
+        max?: number;
+      };
+      /** Match free-text filters as whole strings. Default false: titles ['Founder'] also returns 'Co-Founder' and 'Founder & CEO'. Set true to narrow. Domains, LinkedIn URLs, enum filters and numeric ranges are always exact; keywords is always a loose text probe. */
+      exactMatch?: boolean;
+      preferCache?: boolean;
+    };
+    limit?: number;
+    pageToken?: string;
+    checkDuplicatesAcrossWorkspace?: boolean;
+  };
+  /** Add up to 50 selected recipients without another search. Deduplicates, applies suppression, and preserves the campaign's launch state. — `dench campaign add --people-file` — POST /api/v1/campaigns/{sequenceId}/people/batch */
+  "campaigns.people.addBatch": {
+    sequenceId: string;
+    recipients: {
+      email?: string;
+      linkedinProfileUrl?: string;
+      displayName?: string;
+      /** Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}. */
+      personalization?: Record<string, unknown>;
+    }[];
+    newRecordsObject?: "lead" | "people";
+    checkDuplicatesAcrossWorkspace?: boolean;
+  };
+  /** Read a campaign's saved signal source, targeting and schedule. — `dench campaign sources get` — GET /api/v1/campaigns/{sequenceId}/sources */
+  "campaigns.sources.get": {
+    sequenceId: string;
+  };
+  /** Read signal choices, suggested terms and current source configuration. — `dench campaign sources signals` — GET /api/v1/campaigns/{sequenceId}/sources/signals */
+  "campaigns.sources.signals": {
+    sequenceId: string;
+  };
+  /** Update source cadence, pause/resume, targeting, signals or terms. Active sources may perform billable future work. — `dench campaign sources set` — PATCH /api/v1/campaigns/{sequenceId}/sources */
+  "campaigns.sources.update": {
+    sequenceId: string;
+    status?: "active" | "paused";
+    cadence?: "daily" | "weekly" | "monthly";
+    findMoreMatching?: boolean;
+    targeting?: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+    signal?: {
+      signal: "post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader";
+      enabled: boolean;
+    };
+    terms?: {
+      signal: "post_engagement" | "keyword" | "hiring";
+      values: string[];
+    };
+  };
+  /** Preview a signal source using its current audience. Provider credits may apply; does not enroll people. — `dench campaign sources preview` — POST /api/v1/campaigns/{sequenceId}/sources/preview */
+  "campaigns.sources.preview": {
+    sequenceId: string;
+    signal: "post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader";
+    terms?: string[];
+  };
+  /** Read the company profile and suggested campaign audience. — `dench campaign builder profile` — GET /api/v1/campaigns/builder/profile */
+  "campaigns.builder.profile": Record<string, unknown>;
+  /** Save a signal campaign's audience, signals and terms idempotently. Does not start a build. — `dench campaign builder save` — POST /api/v1/campaigns/builder/drafts */
+  "campaigns.builder.save": {
+    /** Your stable id for this request, 8-64 characters. Retrying with the same id returns the same draft instead of creating another. */
+    clientRequestId: string;
+    targeting: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+    signals: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader">;
+    signalTerms?: {
+      post_engagement?: string[];
+      keyword?: string[];
+      hiring?: string[];
+    };
+  };
+  /** Read signal build progress, preview people, messages and errors. — `dench campaign builder get` — GET /api/v1/campaigns/builder/drafts/{draftId} */
+  "campaigns.builder.get": {
+    draftId: string;
+  };
+  /** Start the same billable signal/audience/message build used by the UI; poll the draft for progress. — `dench campaign builder build` — POST /api/v1/campaigns/builder/drafts/{draftId}/build */
+  "campaigns.builder.build": {
+    draftId: string;
+  };
+  /** Create a campaign from a reviewed signal draft. Does not launch the campaign. — `dench campaign builder create` — POST /api/v1/campaigns/builder/drafts/{draftId}/create */
+  "campaigns.builder.create": {
+    draftId: string;
+    name?: string;
+    timezone?: string;
+  };
+  /** Edit or reset one preview person's opening line before creating the campaign. — `dench campaign builder opener` — PUT /api/v1/campaigns/builder/drafts/{draftId}/people/{leadId}/opener */
+  "campaigns.builder.opener": {
+    draftId: string;
+    leadId: string;
+    opener: string;
+  };
+  /** Turn an audience description into targeting filters. AI credits apply. — `dench campaign builder autofill` — POST /api/v1/campaigns/builder/autofill */
+  "campaigns.builder.autofill": {
+    description: string;
+  };
+  /** Suggest signal terms for the selected audience. AI credits apply. — `dench campaign builder terms` — POST /api/v1/campaigns/builder/terms */
+  "campaigns.builder.terms": {
+    targeting: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+  };
+  /** Estimate audience or weekly signal volume using the UI's cached estimator. Provider credits may apply. — `dench campaign builder estimate` — POST /api/v1/campaigns/builder/estimate */
+  "campaigns.builder.estimate": {
+    kind: "people" | "week";
+    targeting: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+    signals?: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader">;
+    signalTerms?: {
+      post_engagement?: string[];
+      keyword?: string[];
+      hiring?: string[];
+    };
+  };
   /** List all CLI/API operations and parity classifications. — `dench help` — GET /api/v1/commands */
   "commands.list": Record<string, unknown>;
   /** Create an agent sign-in request. — `dench signin` — POST /api/v1/auth/signin-requests */
@@ -104,9 +541,36 @@ export interface ApiRequests {
   /** Get one saved search / list by artifact id. — `dench lists show` — GET /api/v1/lists/{artifactId} */
   "lists.get": Record<string, unknown>;
   /** Save find results as a named list (rows + filters become a workspace artifact). — `dench lists save` — POST /api/v1/lists */
-  "lists.save": Record<string, unknown>;
+  "lists.save": {
+    /** Use find_people, find_companies or find_jobs for a prospect list. */
+    createdFrom: "find_people" | "find_companies" | "find_jobs" | "mixed" | "watch_fire" | "generate_image";
+    /** Name of the new list. */
+    title: string;
+    /** True makes the list visible in Find. Omitted saves an unlisted draft that can still be read or added to a campaign by id. */
+    saved?: boolean;
+    /** Original search filters to retain with the list. Saving does not run a search. */
+    filters?: unknown;
+    /** Complete person records from a search, including existing contact details and custom fields. */
+    people?: Record<string, unknown>[];
+    /** Complete company records from a search. */
+    companies?: Record<string, unknown>[];
+    /** Complete job records from a search. */
+    jobs?: Record<string, unknown>[];
+  };
   /** Update a saved list in place (title, filters, and/or replacement rows). — `dench lists update` — PATCH /api/v1/lists/{artifactId} */
-  "lists.update": Record<string, unknown>;
+  "lists.update": {
+    /** The existing list id. */
+    artifactId: string;
+    title?: string;
+    /** Replacement filter metadata; does not run a new search. */
+    filters?: unknown;
+    /** Replacement people. Omit to preserve existing rows; an empty array clears them. */
+    people?: Record<string, unknown>[];
+    /** Replacement companies. Omit to preserve existing rows. */
+    companies?: Record<string, unknown>[];
+    /** Replacement jobs. Omit to preserve existing rows. */
+    jobs?: Record<string, unknown>[];
+  };
   /** Rename a saved search / list. — `dench lists rename` — POST /api/v1/lists/{artifactId}/rename */
   "lists.rename": Record<string, unknown>;
   /** Delete a saved search / list, its exported CSV/JSONL files, and any linked watch. — `dench lists delete` — DELETE /api/v1/lists/{artifactId} */
@@ -1881,6 +2345,8 @@ export interface ApiRequests {
   "email.sequence.enrollment.stop": Record<string, unknown>;
   /** Discover LinkedIn sender ids, labels, availability and remaining capacity visible to the acting workspace member. Never returns provider credentials. — `dench campaign accounts` — GET /api/v1/campaigns/accounts/linkedin */
   "campaigns.accounts.linkedin": Record<string, unknown>;
+  /** Discover the mailboxes the acting workspace member can send campaign email from: ids for emailMailboxAccountIds, status, warm-up state and when it is done, the daily cold-email cap and what is left today. Never returns provider credentials. — `dench campaign accounts` — GET /api/v1/campaigns/accounts/email */
+  "campaigns.accounts.email": Record<string, unknown>;
   /** List outreach campaigns (archived ones on request). — `dench campaign list` — GET /api/v1/campaigns */
   "campaigns.list": {
     /** Include archived campaigns. */
@@ -1896,6 +2362,11 @@ export interface ApiRequests {
     /** IANA timezone for the default Mon-Fri 9-18 send window. */
     timezone?: string;
   };
+  /** Copy a campaign into a new draft named "<name> copy": the same steps, schedule, sender pools and personalized lines, its lead source paused, and no people. To reach more than 300 people, duplicate and add the next page of the search to the copy. — `dench campaign duplicate` — POST /api/v1/campaigns/{sequenceId}/duplicate */
+  "campaigns.duplicate": {
+    /** The campaign to copy; any status, including archived. */
+    sequenceId: string;
+  };
   /** Read a campaign: settings, steps, people, their current step and hold, last touches, linked leads. — `dench campaign get` — GET /api/v1/campaigns/{sequenceId} */
   "campaigns.get": {
     sequenceId: string;
@@ -1908,6 +2379,10 @@ export interface ApiRequests {
   "campaigns.live": {
     sequenceId: string;
   };
+  /** Where a campaign's people sit in the workspace's lead pipeline right now: each lead Status in order with how many enrolled leads are at it, and how many have no lead or a status outside the pipeline. — `dench campaign pipeline` — GET /api/v1/campaigns/{sequenceId}/pipeline */
+  "campaigns.pipeline": {
+    sequenceId: string;
+  };
   /** Change a campaign's name, sender pools, send windows, daily email cap, stop-on-reply, start or end. Works until archived; existing conversations keep their assigned sender. — `dench campaign set` — PATCH /api/v1/campaigns/{sequenceId} */
   "campaigns.update": {
     sequenceId: string;
@@ -1945,33 +2420,154 @@ export interface ApiRequests {
     /** Cold emails per day, 1-100. */
     dailySendCap?: number;
   };
-  /** Replace every step of a draft campaign (email, wait, LinkedIn visit, connection request, message). Configure sender pools on the campaign; step sender ids are legacy-only. — `dench campaign steps set` — PUT /api/v1/campaigns/{sequenceId}/steps */
+  /** Replace every step of a draft campaign (email, wait, LinkedIn visit, connection request, message, post reaction, InMail). Steps are checked first: a field the step type would drop, missing text or {TOKEN} single braces are rejected, not saved. Configure sender pools on the campaign; step sender ids are legacy-only. — `dench campaign steps set` — PUT /api/v1/campaigns/{sequenceId}/steps */
   "campaigns.steps.replace": {
     sequenceId: string;
+    /** Every step, in send order. Rejected, not trimmed: a field the step type would drop (onlyIf off email/post-like steps, a body on a visit, reply-in-thread on the first email), a missing subject or required body, an overlength note/message/InMail subject, out-of-range wait/withdrawal/post-age values, and {TOKEN} single braces, which would be sent as typed. */
     steps: Array<{
       /** Step type. */
-      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message";
+      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message" | "linkedin_like_post" | "linkedin_inmail";
       /** wait steps: hours to wait before the next step. */
       waitHours?: number;
       /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
       emailMailboxAccountId?: string;
       /** email steps: subject; {{Column}} merge tokens allowed. */
       emailSubject?: string;
+      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
       emailHtmlBody?: string;
+      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
       emailTextBody?: string;
       /** email steps: thread under the previous email step instead of a new subject. */
       emailReplyToPrevious?: boolean;
-      /** Run this step only when the person is / is not a LinkedIn connection. */
+      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
       onlyIf?: "always" | "connected" | "not_connected";
       /** Legacy LinkedIn step sender. Pool campaigns use the campaign's linkedinAccountIds instead. */
       linkedinAccountId?: string;
-      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the message (up to 3000 chars). */
+      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
       linkedinMessageBody?: string;
       /** linkedin_message: what to do when the invite is still pending. */
       linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
-      /** linkedin_message with linkedinMessageMode=wait_until_connected: give up waiting for the accept after this many hours (default 720). */
+      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720). After a connection step this mode is the default. */
       connectionTimeoutHours?: number;
+      /** linkedin_like_post only: the reaction to leave (default like). */
+      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
+      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
+      likeMaxPostAgeDays?: number;
+      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
+      likeSkipNextWait?: boolean;
+      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
+      inmailSubject?: string;
+      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
+      withdrawAfterHours?: number | null;
     }>;
+    /** Send {single braces} exactly as typed instead of rejecting them. Merge tokens always use {{double braces}}. */
+    allowSingleBraces?: boolean;
+  };
+  /** Edit the text, waits and conditions of a launched (or paused) campaign's steps in place. Each step keeps its id, type and place; pass the stepId and the updatedAt you read, and only the fields you change. Messages already sent or being prepared keep their text; drafts use campaigns.steps.replace. — `dench campaign steps edit` — PATCH /api/v1/campaigns/{sequenceId}/steps */
+  "campaigns.steps.update": {
+    sequenceId: string;
+    /** The steps to change. Rejected, not trimmed: a field the step type would drop, an overlength note/message/InMail subject, out-of-range wait/withdrawal/post-age values, and {TOKEN} single braces. */
+    steps: Array<{
+      /** The step's current type. A launched step's type can't change. */
+      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message" | "linkedin_like_post" | "linkedin_inmail";
+      /** wait steps: hours to wait before the next step. */
+      waitHours?: number;
+      /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
+      emailMailboxAccountId?: string;
+      /** email steps: subject; {{Column}} merge tokens allowed. */
+      emailSubject?: string;
+      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
+      emailHtmlBody?: string;
+      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
+      emailTextBody?: string;
+      /** email steps: thread under the previous email step instead of a new subject. */
+      emailReplyToPrevious?: boolean;
+      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
+      onlyIf?: "always" | "connected" | "not_connected";
+      /** Legacy LinkedIn step sender. Pool campaigns use the campaign's linkedinAccountIds instead. */
+      linkedinAccountId?: string;
+      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
+      linkedinMessageBody?: string;
+      /** linkedin_message: what to do when the invite is still pending. */
+      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
+      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720). After a connection step this mode is the default. */
+      connectionTimeoutHours?: number;
+      /** linkedin_like_post only: the reaction to leave (default like). */
+      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
+      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
+      likeMaxPostAgeDays?: number;
+      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
+      likeSkipNextWait?: boolean;
+      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
+      inmailSubject?: string;
+      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
+      withdrawAfterHours?: number | null;
+      /** The step's _id from campaigns.get steps[]. */
+      stepId: string;
+      /** The step's updatedAt when you read it. If someone saved it since, the edit is refused instead of overwriting theirs. */
+      expectedUpdatedAt: number;
+    }>;
+    /** Send {single braces} exactly as typed instead of rejecting them. Merge tokens always use {{double braces}}. */
+    allowSingleBraces?: boolean;
+  };
+  /** Read a campaign's personalized lines (written for each person): their {{keys}} for steps, instructions and fallbacks, how many people have them, and the cost per person. — `dench campaign personalize get` — GET /api/v1/campaigns/{sequenceId}/personalization */
+  "campaigns.personalization.get": {
+    sequenceId: string;
+  };
+  /** Define up to 5 personalized lines (each used as {{key}} in steps) and what you sell. Saving starts writing missing lines for up to 100 people, about 3 cents a person; for more it returns needsConfirm and writes nothing until campaigns.personalization.write is confirmed. — `dench campaign personalize set` — PUT /api/v1/campaigns/{sequenceId}/personalization */
+  "campaigns.personalization.set": {
+    sequenceId: string;
+    /** The lines and context; null turns personalized lines off. */
+    template: {
+      variables: {
+        /** The {{key}} used in steps: a letter, then letters, digits or _ (up to 40). Not a built-in field like firstName or company. */
+        key: string;
+        /** The line's name, up to 60 characters. */
+        label: string;
+        /** What the writer should say, up to 600 characters. */
+        prompt: string;
+        /** Sent when there is nothing specific to say; up to 300 characters, no {{variables}}. */
+        fallback: string;
+        /** A field to use before the fallback, e.g. Company. */
+        fallbackFrom?: string;
+        /** The longest line, default 200 characters. */
+        maxChars?: number;
+      }[];
+      context: {
+        /** What you sell, up to 1000 characters. */
+        sells: string;
+        /** The offer or call to action, up to 300 characters. */
+        offer?: string;
+      };
+    } | null;
+  };
+  /** Turn off a campaign's personalized lines and cancel the ones not yet written. Refused while a step still uses one of the {{keys}}. — `dench campaign personalize clear` — DELETE /api/v1/campaigns/{sequenceId}/personalization */
+  "campaigns.personalization.clear": {
+    sequenceId: string;
+  };
+  /** Write personalized lines for the people missing them (mode missing) or rewrite everyone's (mode all). Rewriting everyone or more than 100 people returns needsConfirm and the estimate until called with confirmed: true. — `dench campaign personalize write` — POST /api/v1/campaigns/{sequenceId}/personalization/write */
+  "campaigns.personalization.write": {
+    sequenceId: string;
+    /** missing (default): only people without lines. all: rewrite everyone's. */
+    mode?: "missing" | "all";
+    /** true after the user accepts the estimate from needsConfirm. */
+    confirmed?: boolean;
+  };
+  /** Set one person's personalized line by hand; an empty value undoes the edit. Braces are removed and text past the line's length is cut. — `dench campaign personalize edit` — PUT /api/v1/campaigns/people/{enrollmentId}/personalization */
+  "campaigns.personalization.edit": {
+    /** From dench campaign people. */
+    enrollmentId: string;
+    /** The line's key, as in {{key}}. */
+    key: string;
+    /** The line to send; an empty string undoes the edit. */
+    value: string;
+  };
+  /** Write a fresh personalized line for one person: one key, or all of their lines when key is left out. About 3 cents. — `dench campaign personalize rewrite` — POST /api/v1/campaigns/people/{enrollmentId}/personalization/rewrite */
+  "campaigns.personalization.rewrite": {
+    /** From dench campaign people. */
+    enrollmentId: string;
+    /** One line's key; leave out to rewrite all of their lines. */
+    key?: string;
   };
   /** Add CRM records (up to 100 ids per call) to a campaign; returns how many were added and why others were skipped. — `dench campaign add` — POST /api/v1/campaigns/{sequenceId}/people */
   "campaigns.people.addFromCrm": {
@@ -2008,7 +2604,15 @@ export interface ApiRequests {
     personalization?: Record<string, unknown>;
     checkDuplicatesAcrossWorkspace?: boolean;
   };
-  /** Launch readiness: blockers grouped by problem, warnings, and the fingerprint `launch` requires. — `dench campaign launch` — GET /api/v1/campaigns/{sequenceId}/launch */
+  /** Show the message one person gets at one email or LinkedIn step, with their fields and personalized lines filled in: subject, body, sender, recipient, merge fields still missing, warnings, and why the step would be skipped. Nothing is sent, prepared or charged. — `dench campaign preview` — GET /api/v1/campaigns/{sequenceId}/preview */
+  "campaigns.preview": {
+    sequenceId: string;
+    /** The person to preview, from dench campaign people. */
+    enrollmentId: string;
+    /** An email or LinkedIn step, its _id from campaigns.get steps[]. A wait step sends nothing. */
+    stepId: string;
+  };
+  /** Launch readiness without launching: blockers grouped by problem, warnings, and the fingerprint `launch` requires. — `dench campaign launch --check` — GET /api/v1/campaigns/{sequenceId}/launch */
   "campaigns.launch.preview": {
     sequenceId: string;
   };
@@ -2028,7 +2632,7 @@ export interface ApiRequests {
   "campaigns.resume": {
     sequenceId: string;
   };
-  /** Archive a campaign and stop everyone still in flight. — `dench campaign archive` — POST /api/v1/campaigns/{sequenceId}/archive */
+  /** Archive a campaign and stop everyone still in flight. This is the app's Delete: campaigns are never erased, and their people, leads and activity stay. — `dench campaign archive` — POST /api/v1/campaigns/{sequenceId}/archive */
   "campaigns.archive": {
     sequenceId: string;
   };
@@ -2048,6 +2652,53 @@ export interface ApiRequests {
   "campaigns.people.resume": {
     enrollmentId: string;
   };
+  /** Give a person in a draft campaign a new or corrected email address; their linked CRM record gets it too. Only before launch; another person in the campaign can't share it. — `dench campaign person set --email` — PUT /api/v1/campaigns/people/{enrollmentId}/email */
+  "campaigns.people.setEmail": {
+    /** From dench campaign people. */
+    enrollmentId: string;
+    /** The address email steps should use. */
+    email: string;
+  };
+  /** Give a person in a draft campaign a new or corrected LinkedIn profile URL; their linked CRM record gets it too. Only before launch. — `dench campaign person set --linkedin-url` — PUT /api/v1/campaigns/people/{enrollmentId}/linkedin */
+  "campaigns.people.setLinkedin": {
+    /** From dench campaign people. */
+    enrollmentId: string;
+    /** A LinkedIn member profile URL, e.g. https://linkedin.com/in/ada. */
+    linkedinProfileUrl: string;
+  };
+  /** Fill or fix one {{merge field}} for a person in a draft campaign, e.g. a missing Company that blocks launch; a matching column on their CRM record is updated too. Only before launch; written personalized lines are not merge fields and can't be set here. — `dench campaign person set --field` — PUT /api/v1/campaigns/people/{enrollmentId}/fields */
+  "campaigns.people.setField": {
+    /** From dench campaign people. */
+    enrollmentId: string;
+    /** The merge token name without braces, e.g. Company for {{Company}} or fund for {{fund}}. */
+    key: string;
+    /** Up to 2000 characters. */
+    value: string;
+  };
+  /** Resume every paused person in an active campaign at once, e.g. after a sending account is reconnected. Returns how many were resumed. — `dench campaign resume-person --all` — POST /api/v1/campaigns/{sequenceId}/people/resume */
+  "campaigns.people.resumeAll": {
+    /** An active campaign. */
+    sequenceId: string;
+  };
+  /** Fill each unfinished person's empty email, LinkedIn URL, name and merge fields from their linked CRM record, e.g. after enriching the records. Never overwrites a value the campaign already has; returns how many people changed. — `dench campaign sync` — POST /api/v1/campaigns/{sequenceId}/people/sync */
+  "campaigns.people.sync": {
+    sequenceId: string;
+  };
+  /** The campaigns a CRM record (a person or a lead) is in, newest first, with the person's status in each and the accounts that send to them. — `dench campaign where` — GET /api/v1/campaigns/by-record/{entryId} */
+  "campaigns.people.forRecord": {
+    /** A CRM record's _id: a person, or a lead created from one. */
+    entryId: string;
+  };
+  /** Everything a campaign did for one person, step by step: what was sent (subject and text), whether it was opened or clicked, what was skipped and why, waits, failures and retries. — `dench campaign person show` — GET /api/v1/campaigns/people/{enrollmentId}/timeline */
+  "campaigns.people.timeline": {
+    /** From dench campaign people. */
+    enrollmentId: string;
+  };
+  /** Remove a person who was never contacted from a draft campaign. Frees their place in the 300-person cap and keeps the draft launchable; stop anyone already contacted instead. — `dench campaign remove` — DELETE /api/v1/campaigns/people/{enrollmentId} */
+  "campaigns.people.remove": {
+    /** From dench campaign people; the person must never have been contacted. */
+    enrollmentId: string;
+  };
   /** List routines. — `dench cron list` — GET /api/v1/routines */
   "cron.list": {
     enabledOnly?: boolean;
@@ -2290,7 +2941,7 @@ export interface ApiRequests {
     /** Optional base64 mask image. */
     mask_base64?: string;
   };
-  /** List every connected integration — Composio apps plus the Gmail, Outlook, Calendar, LinkedIn and Slack connections Dench brokers itself (Slack rows report source: dench). — `dench integrations` — GET /api/v1/integrations */
+  /** List every connected integration — connected apps plus the Gmail, Outlook, Calendar, LinkedIn and Slack connections Dench provides itself (Slack rows report source: dench). — `dench integrations` — GET /api/v1/integrations */
   "integrations.list": Record<string, unknown>;
   /** List installed App Store apps in the workspace. — `dench apps list` — GET /api/v1/apps */
   "apps.list": Record<string, unknown>;
@@ -2361,7 +3012,7 @@ export interface ApiRequests {
   };
   /** List connected tool accounts. — `dench tool status` — GET /api/v1/tools/status */
   "tool.status": Record<string, unknown>;
-  /** Create a tool OAuth connection link. Slack is in-house, never Composio: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. — `dench tool connect` — POST /api/v1/tools/connections */
+  /** Create a tool OAuth connection link. Slack is in-house, never a third-party connection: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. — `dench tool connect` — POST /api/v1/tools/connections */
   "tool.connect": {
     /** Toolkit slug, e.g. github, gmail, stripe. */
     toolkit: string;
@@ -2382,12 +3033,12 @@ export interface ApiRequests {
     account?: string;
     model?: string;
   };
-  /** Run an external tool action. SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through Dench's in-house Slack app install — any channel in the connected workspace — and are always preferred over Composio Slack. — `dench tool run` — POST /api/v1/tools/run */
+  /** Run an external tool action. SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through Dench's in-house Slack app install — any channel in the connected workspace — and are always preferred over any third-party Slack connection. — `dench tool run` — POST /api/v1/tools/run */
   "tool.run": {
     /** Execution ref from a prior search, OR pass session_id+tool_slug. */
     execution_ref?: string;
     session_id?: string;
-    /** Composio tool slug, e.g. GMAIL_FETCH_EMAILS. */
+    /** Tool slug, e.g. GMAIL_FETCH_EMAILS. */
     tool_slug?: string;
     /** Tool arguments object. */
     arguments?: Record<string, unknown>;
@@ -2525,6 +3176,133 @@ export interface ApiRequests {
 }
 
 export interface ApiResponses {
+  "campaigns.drafts.create": {
+    sequenceId: string;
+  };
+  "campaigns.audience.search": {
+    rows: Record<string, unknown>[];
+    people: unknown[];
+    recipients: {
+      email?: string;
+      linkedinProfileUrl?: string;
+      displayName?: string;
+      /** Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}. */
+      personalization?: Record<string, unknown>;
+    }[];
+    metadata: Record<string, unknown>;
+    /** The search cost ceiling reported by Dench billing, in cents. Null means the receipt is unavailable. */
+    estimatedCents: number | null;
+    /** The actual search charge reported by Dench billing, in cents. Null means the receipt is unavailable; results remain valid. */
+    chargedCents: number | null;
+  };
+  "campaigns.people.addFromSearch": {
+    rows: Record<string, unknown>[];
+    people: unknown[];
+    recipients: {
+      email?: string;
+      linkedinProfileUrl?: string;
+      displayName?: string;
+      /** Merge values keyed by name, e.g. {"Company":"Acme"} for {{Company}}. */
+      personalization?: Record<string, unknown>;
+    }[];
+    metadata: Record<string, unknown>;
+    /** The search cost ceiling reported by Dench billing, in cents. Null means the receipt is unavailable. */
+    estimatedCents: number | null;
+    /** The actual search charge reported by Dench billing, in cents. Null means the receipt is unavailable; results remain valid. */
+    chargedCents: number | null;
+    added: number;
+    requested: number;
+    cappedAtLimit: number | null;
+    duplicates: number;
+    duplicatesElsewhere: number;
+    suppressed: number;
+    invalid: number;
+    skippedNoIdentity: number;
+    skippedMissingInfo: number;
+    missingInfoSample?: unknown;
+    found: number;
+    skippedSearchProfiles: number;
+  };
+  "campaigns.people.addBatch": {
+    added: number;
+    requested: number;
+    cappedAtLimit: number | null;
+    duplicates: number;
+    duplicatesElsewhere: number;
+    suppressed: number;
+    invalid: number;
+    skippedNoIdentity: number;
+    skippedMissingInfo: number;
+    missingInfoSample?: unknown;
+  };
+  "campaigns.sources.get": Record<string, unknown> | null;
+  "campaigns.sources.signals": Record<string, unknown> | null;
+  "campaigns.sources.update": null;
+  "campaigns.sources.preview": {
+    ok: boolean;
+    [key: string]: unknown;
+  };
+  "campaigns.builder.profile": {
+    hasProfile: boolean;
+    targeting: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+    [key: string]: unknown;
+  };
+  "campaigns.builder.save": {
+    draftId: string;
+  };
+  "campaigns.builder.get": {
+    status: string;
+    targeting: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+    signals: Array<"post_engagement" | "keyword" | "hiring" | "funding" | "launch" | "new_leader">;
+    people: Record<string, unknown>[];
+    [key: string]: unknown;
+  };
+  "campaigns.builder.build": {
+    ok: boolean;
+    started: boolean;
+  };
+  "campaigns.builder.create": {
+    sequenceId: string;
+    enrolled: number;
+  };
+  "campaigns.builder.opener": null;
+  "campaigns.builder.autofill": {
+    targeting: {
+      titles: string[];
+      locations: string[];
+      companySizes: string[];
+      industries: string[];
+      excludes: string[];
+      companies?: string[];
+    };
+    [key: string]: unknown;
+  };
+  "campaigns.builder.terms": {
+    signalTerms: {
+      post_engagement?: string[];
+      keyword?: string[];
+      hiring?: string[];
+    };
+    [key: string]: unknown;
+  };
+  "campaigns.builder.estimate": {
+    count: number | null;
+    [key: string]: unknown;
+  };
   "commands.list": {
     operations: Array<{
       id: string;
@@ -2534,7 +3312,7 @@ export interface ApiResponses {
       aliases: string[];
       method: string;
       path: string;
-      backend: "convex" | "gateway" | "custom" | "local";
+      backend: "api" | "gateway" | "custom" | "local";
       deprecated: boolean;
     }>;
   };
@@ -2962,8 +3740,20 @@ export interface ApiResponses {
   "lists.rows": unknown;
   "lists.import": unknown;
   "lists.get": unknown;
-  "lists.save": unknown;
-  "lists.update": unknown;
+  "lists.save": {
+    artifactId: string;
+    filePath: string;
+    rowCount: number;
+    previewRows: unknown[];
+    title: string;
+    createdFrom: string;
+  };
+  "lists.update": {
+    artifactId: string;
+    rowCount: number;
+    previewRows: unknown[];
+    title: string;
+  };
   "lists.rename": unknown;
   "lists.delete": unknown;
   "lists.prospects.reviews": unknown;
@@ -4233,7 +5023,7 @@ export interface ApiResponses {
   };
   "crm.people.search": {
     source: "live" | "cache";
-    /** Provider results normalized to the CRM upsert shape. */
+    /** Search results normalized to the CRM upsert shape. */
     people: {
       fullName?: string;
       firstName?: string;
@@ -4250,6 +5040,12 @@ export interface ApiResponses {
     }[];
     resolvedPersonIds: string[];
     creditsCharged: number;
+    billing?: {
+      /** Search cost ceiling authorized by Dench billing, in cents. */
+      estimatedCents: number;
+      /** Actual workspace search charge reported by Dench billing, in cents. */
+      chargedCents: number;
+    };
     metadata?: {
       /** Total matches for the search. Stable across pages; absent when only an estimate exists. */
       total?: number;
@@ -4264,7 +5060,7 @@ export interface ApiResponses {
   };
   "crm.companies.search": {
     source: "live" | "cache";
-    /** Provider results normalized to the CRM upsert shape. */
+    /** Search results normalized to the CRM upsert shape. */
     companies: {
       name?: string;
       website?: string;
@@ -4278,6 +5074,12 @@ export interface ApiResponses {
     }[];
     resolvedCompanyIds: string[];
     creditsCharged: number;
+    billing?: {
+      /** Search cost ceiling authorized by Dench billing, in cents. */
+      estimatedCents: number;
+      /** Actual workspace search charge reported by Dench billing, in cents. */
+      chargedCents: number;
+    };
     metadata?: {
       /** Total matches for the search. Stable across pages; absent when only an estimate exists. */
       total?: number;
@@ -4788,6 +5590,26 @@ export interface ApiResponses {
     /** Account availability snapshot. Queued work, campaign limits and launch/dispatch checks still apply. */
     availability: "ready" | "paused" | "disconnected" | "errored" | "disabled" | "circuit_break" | "spacing" | "outside_window" | "daily_cap";
   }>;
+  "campaigns.accounts.email": Array<{
+    /** The emailMailboxAccountId to put in emailMailboxAccountIds. */
+    _id: string;
+    email: string;
+    provider: "gmail" | "outlook";
+    status: "running" | "disconnected" | "errored";
+    statusReason?: string;
+    /** ready or skipped: sends at its cap. warming: sends less until readyAt. pending_auth and error need the owner in the app. */
+    warmupStatus: "skipped" | "pending_auth" | "warming" | "ready" | "error";
+    /** When warm-up finished, or is expected to finish while warming (epoch ms). */
+    readyAt?: number;
+    /** The most cold emails a day; the mailbox owner sets it in the app. */
+    dailyColdSendCap: number;
+    /** Cold emails it can still send today. */
+    remainingToday: number;
+    ownerName: string;
+    isOwner: boolean;
+    visibility: "private" | "shared";
+    [key: string]: unknown;
+  }>;
   "campaigns.list": Array<{
     _id: string;
     name: string;
@@ -4832,6 +5654,10 @@ export interface ApiResponses {
   "campaigns.create": {
     sequenceId: string;
   };
+  "campaigns.duplicate": {
+    /** The new draft. Rename it with campaigns.update. */
+    sequenceId: string;
+  };
   "campaigns.get": {
     sequence: {
       _id: string;
@@ -4876,27 +5702,39 @@ export interface ApiResponses {
     };
     steps: Array<{
       /** Step type. */
-      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message";
+      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message" | "linkedin_like_post" | "linkedin_inmail";
       /** wait steps: hours to wait before the next step. */
       waitHours?: number;
       /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
       emailMailboxAccountId?: string;
       /** email steps: subject; {{Column}} merge tokens allowed. */
       emailSubject?: string;
+      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
       emailHtmlBody?: string;
+      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
       emailTextBody?: string;
       /** email steps: thread under the previous email step instead of a new subject. */
       emailReplyToPrevious?: boolean;
-      /** Run this step only when the person is / is not a LinkedIn connection. */
+      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
       onlyIf?: "always" | "connected" | "not_connected";
       /** Legacy LinkedIn step sender. Pool campaigns use the campaign's linkedinAccountIds instead. */
       linkedinAccountId?: string;
-      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the message (up to 3000 chars). */
+      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
       linkedinMessageBody?: string;
       /** linkedin_message: what to do when the invite is still pending. */
       linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
-      /** linkedin_message with linkedinMessageMode=wait_until_connected: give up waiting for the accept after this many hours (default 720). */
+      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720). After a connection step this mode is the default. */
       connectionTimeoutHours?: number;
+      /** linkedin_like_post only: the reaction to leave (default like). */
+      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
+      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
+      likeMaxPostAgeDays?: number;
+      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
+      likeSkipNextWait?: boolean;
+      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
+      inmailSubject?: string;
+      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
+      withdrawAfterHours?: number | null;
       [key: string]: unknown;
     }>;
     enrollments: Record<string, unknown>[];
@@ -4949,6 +5787,20 @@ export interface ApiResponses {
     senders: Record<string, unknown>[];
     [key: string]: unknown;
   };
+  "campaigns.pipeline": {
+    /** People in the campaign. */
+    total: number;
+    /** The workspace's lead Statuses, in pipeline order. */
+    statuses: {
+      /** A lead Status, as named in the CRM. */
+      name: string;
+      color: string;
+      /** Enrolled leads at this Status. */
+      count: number;
+    }[];
+    /** People with no lead, or a Status outside the pipeline. */
+    other: number;
+  } | null;
   "campaigns.update": {
     ok: boolean;
   };
@@ -4956,6 +5808,95 @@ export interface ApiResponses {
     ok: boolean;
     stepCount: number;
   };
+  "campaigns.steps.update": {
+    ok: boolean;
+    /** How many steps were edited. */
+    stepCount: number;
+  };
+  "campaigns.personalization.get": {
+    template: {
+      variables: {
+        /** The {{key}} used in steps: a letter, then letters, digits or _ (up to 40). Not a built-in field like firstName or company. */
+        key: string;
+        /** The line's name, up to 60 characters. */
+        label: string;
+        /** What the writer should say, up to 600 characters. */
+        prompt: string;
+        /** Sent when there is nothing specific to say; up to 300 characters, no {{variables}}. */
+        fallback: string;
+        /** A field to use before the fallback, e.g. Company. */
+        fallbackFrom?: string;
+        /** The longest line, default 200 characters. */
+        maxChars?: number;
+      }[];
+      context: {
+        /** What you sell, up to 1000 characters. */
+        sells: string;
+        /** The offer or call to action, up to 300 characters. */
+        offer?: string;
+      };
+      version: number;
+      updatedAt: number;
+      [key: string]: unknown;
+    } | null;
+    counts: {
+      done: number;
+      pending: number;
+      failed: number;
+      total: number;
+    };
+    paused: boolean;
+    notice: {
+      code: "insufficient_credits";
+      at: number;
+    } | null;
+    suggestedContext: {
+      sells?: string;
+    };
+    estimatedCentsPerPerson: number;
+    eligible: number;
+    [key: string]: unknown;
+  };
+  "campaigns.personalization.set": {
+    version: number;
+    /** People who would get a line. */
+    eligible: number;
+    /** About 3 cents a person. */
+    estimatedCents: number;
+    /** True when nothing was written: confirm with campaigns.personalization.write and confirmed: true. */
+    needsConfirm: boolean;
+    /** People whose lines are being written now. */
+    queued: number;
+  };
+  "campaigns.personalization.clear": {
+    version: number;
+    /** People who would get a line. */
+    eligible: number;
+    /** About 3 cents a person. */
+    estimatedCents: number;
+    /** True when nothing was written: confirm with campaigns.personalization.write and confirmed: true. */
+    needsConfirm: boolean;
+    /** People whose lines are being written now. */
+    queued: number;
+  };
+  "campaigns.personalization.write": {
+    version: number;
+    /** People who would get a line. */
+    eligible: number;
+    /** About 3 cents a person. */
+    estimatedCents: number;
+    /** True when nothing was written: confirm with campaigns.personalization.write and confirmed: true. */
+    needsConfirm: boolean;
+    /** People whose lines are being written now. */
+    queued: number;
+  };
+  "campaigns.personalization.edit": {
+    ok: boolean;
+  };
+  "campaigns.personalization.rewrite": {
+    /** False when new lines are already being written. */
+    queued: boolean;
+  };
   "campaigns.people.addFromCrm": {
     added: number;
     requested: number;
@@ -4982,6 +5923,44 @@ export interface ApiResponses {
   "campaigns.people.add": {
     enrollmentId: string;
   };
+  "campaigns.preview": {
+    channel: "email" | "linkedin";
+    /** Email steps. */
+    subject?: string;
+    /** Email steps: plain text. */
+    textBody?: string;
+    /** Email steps: HTML. */
+    htmlBody?: string;
+    /** LinkedIn steps: the note or message, or a line saying no note or message is sent. */
+    messageBody?: string;
+    /** The sending account. */
+    fromName?: string;
+    fromEmail?: string;
+    toName: string;
+    toEmail?: string;
+    /** {{merge fields}} this person has no value for; fill them with campaigns.people.setField. */
+    missingFields: string[];
+    warnings: string[];
+    /** Set when the person would skip this step, e.g. no email address. */
+    skippedReason?: string;
+    highlights?: string[];
+    personalized?: Array<{
+      /** The line's {{key}}. */
+      key: string;
+      label: string;
+      /** What this person gets: the written line, or the fallback. */
+      value: string;
+      /** written or edited: the line is final. fallback: nothing specific was found, so the fallback is used. writing, paused and not_written: the fallback shows until the line is written. */
+      state: "written" | "edited" | "writing" | "paused" | "fallback" | "not_written";
+      /** What the line was written from. */
+      source?: "company" | "news" | "signal" | "profile" | "fallback";
+      maxChars: number;
+      /** A new line is being written over the current one. */
+      rewriting?: "writing" | "paused";
+      [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+  };
   "campaigns.launch.preview": {
     ready: boolean;
     /** Pass this to `launch`; it changes whenever the campaign changes. */
@@ -5033,6 +6012,120 @@ export interface ApiResponses {
   "campaigns.people.resume": {
     ok: boolean;
   };
+  "campaigns.people.setEmail": {
+    ok: boolean;
+  };
+  "campaigns.people.setLinkedin": {
+    ok: boolean;
+  };
+  "campaigns.people.setField": {
+    ok: boolean;
+  };
+  "campaigns.people.resumeAll": {
+    /** How many paused people were resumed. */
+    resumed: number;
+  };
+  "campaigns.people.sync": {
+    /** How many people gained a detail from their CRM record. */
+    updated: number;
+  };
+  "campaigns.people.forRecord": Array<{
+    /** The person in that campaign: _id, sequenceId, status, currentStepIndex, repliedAt. */
+    enrollment: Record<string, unknown>;
+    sequenceName: string;
+    isOwner: boolean;
+    canManage: boolean;
+    /** The accounts that send to this person. */
+    senders: {
+      email: {
+        accountId: string;
+        /** The mailbox address or LinkedIn name. */
+        label: string;
+        status: string;
+      } | null;
+      linkedin: {
+        accountId: string;
+        /** The mailbox address or LinkedIn name. */
+        label: string;
+        status: string;
+      } | null;
+    };
+    [key: string]: unknown;
+  }>;
+  "campaigns.people.timeline": {
+    /** The person in this campaign: status, lastError, repliedAt. */
+    enrollment: Record<string, unknown>;
+    sequence: Record<string, unknown> | null;
+    /** The campaign's steps in order, each with its _id. */
+    steps: Array<{
+      /** Step type. */
+      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message" | "linkedin_like_post" | "linkedin_inmail";
+      /** wait steps: hours to wait before the next step. */
+      waitHours?: number;
+      /** Legacy email step sender. Pool campaigns choose senders in emailMailboxAccountIds on the campaign, not on individual steps. */
+      emailMailboxAccountId?: string;
+      /** email steps: subject; {{Column}} merge tokens allowed. */
+      emailSubject?: string;
+      /** email steps: HTML body. Sent instead of emailTextBody when both are set, so when you edit the text, update or drop this too. */
+      emailHtmlBody?: string;
+      /** email steps: plain-text body; used as the email when there is no emailHtmlBody. */
+      emailTextBody?: string;
+      /** email steps: thread under the previous email step instead of a new subject. */
+      emailReplyToPrevious?: boolean;
+      /** email and linkedin_like_post only: always (default), connected or not_connected. InMail automatically skips connected people; do not set a condition on it. */
+      onlyIf?: "always" | "connected" | "not_connected";
+      /** Legacy LinkedIn step sender. Pool campaigns use the campaign's linkedinAccountIds instead. */
+      linkedinAccountId?: string;
+      /** linkedin_connection: the invite note (optional, up to 300 chars; sent without it if LinkedIn refuses the note); linkedin_message: the required message (up to 3000 chars); linkedin_inmail: the required message (up to 1900 chars). */
+      linkedinMessageBody?: string;
+      /** linkedin_message: what to do when the invite is still pending. */
+      linkedinMessageMode?: "skip_if_not_connected" | "wait_until_connected";
+      /** linkedin_message with linkedinMessageMode=wait_until_connected: wait 1-2160 hours for acceptance (default 720). After a connection step this mode is the default. */
+      connectionTimeoutHours?: number;
+      /** linkedin_like_post only: the reaction to leave (default like). */
+      likeReaction?: "like" | "celebrate" | "support" | "love" | "insightful" | "funny";
+      /** linkedin_like_post only: select the newest eligible original post from the last 1-365 days (default 30). */
+      likeMaxPostAgeDays?: number;
+      /** linkedin_like_post only: skip consecutive following wait steps whenever the reaction step is skipped (default true). False keeps those waits. */
+      likeSkipNextWait?: boolean;
+      /** linkedin_inmail only: optional subject, up to 200 characters; merge tokens allowed. Clear with an empty string. */
+      inmailSubject?: string;
+      /** linkedin_connection only: withdraw a still-pending invitation sent by this campaign after 168-2160 hours (7-90 days). Omitted means off on creation; null turns it off on edit. */
+      withdrawAfterHours?: number | null;
+      [key: string]: unknown;
+    }>;
+    /** One run for each step the person has reached, in order. */
+    runs: Array<{
+      _id: string;
+      /** The step's _id, as in steps[]. */
+      stepId: string;
+      /** The step's place, from 0. */
+      stepIndex: number;
+      /** Step type. */
+      type: "email" | "wait" | "linkedin_visit" | "linkedin_connection" | "linkedin_message" | "linkedin_like_post" | "linkedin_inmail";
+      /** sent: done (a wait that finished is sent too). skipped: see result.reason. retry: will be tried again at retryAt. unknown: needs a look. */
+      status: "queued" | "running" | "waiting" | "retry" | "sent" | "skipped" | "failed" | "unknown";
+      scheduledAt?: number;
+      startedAt?: number;
+      waitUntil?: number;
+      retryAt?: number;
+      completedAt?: number;
+      /** The email this run sent, in emailMessages[]. */
+      emailMessageId?: string;
+      lastError?: string;
+      /** For a skipped step, { reason } says why. */
+      result?: unknown;
+      [key: string]: unknown;
+    }>;
+    /** The emails those runs sent: subject, textBody, status, sentAt, firstOpenedAt, firstClickedAt. */
+    emailMessages: Record<string, unknown>[];
+    /** The LinkedIn messages those runs sent: text, sentAt, deliveredAt, readAt, outreachStepRunId. */
+    linkedinMessages: Record<string, unknown>[];
+    [key: string]: unknown;
+  };
+  "campaigns.people.remove": {
+    ok: boolean;
+  };
   "cron.list": {
     jobs: Array<{
       id: string;
@@ -5411,7 +6504,7 @@ export interface ApiResponses {
       reconnect?: Record<string, unknown>;
       [key: string]: unknown;
     }>;
-    /** Raw Composio payload. */
+    /** Deprecated: the unprocessed provider response. Do not depend on it. */
     raw: unknown;
     [key: string]: unknown;
   };
@@ -5463,7 +6556,7 @@ export interface ApiResponses {
       reconnect?: Record<string, unknown>;
       [key: string]: unknown;
     }>;
-    /** Raw Composio payload. */
+    /** Deprecated: the unprocessed provider response. Do not depend on it. */
     raw: unknown;
     [key: string]: unknown;
   };
@@ -6170,15 +7263,47 @@ export type DenchApiTree = {
   };
   campaigns: {
     accounts: {
+      /** Discover the mailboxes the acting workspace member can send campaign email from: ids for emailMailboxAccountIds, status, warm-up state and when it is done, the daily cold-email cap and what is left today. Never returns provider credentials. (`dench campaign accounts`) */
+      email(args?: Req<"campaigns.accounts.email">): Promise<Res<"campaigns.accounts.email">>;
       /** Discover LinkedIn sender ids, labels, availability and remaining capacity visible to the acting workspace member. Never returns provider credentials. (`dench campaign accounts`) */
       linkedin(args?: Req<"campaigns.accounts.linkedin">): Promise<Res<"campaigns.accounts.linkedin">>;
     };
     /** Campaign funnel: enrolled, contacted, invited, accepted, messaged, replied, opens and clicks. (`dench campaign get`) */
     analytics(args: Req<"campaigns.analytics">): Promise<Res<"campaigns.analytics">>;
-    /** Archive a campaign and stop everyone still in flight. (`dench campaign archive`) */
+    /** Archive a campaign and stop everyone still in flight. This is the app's Delete: campaigns are never erased, and their people, leads and activity stay. (`dench campaign archive`) */
     archive(args: Req<"campaigns.archive">): Promise<Res<"campaigns.archive">>;
+    audience: {
+      /** Search people by filters without adding CRM records or campaign recipients. Search credits apply; this is not a free provider preview. (`dench campaign search`) */
+      search(args: Req<"campaigns.audience.search">): Promise<Res<"campaigns.audience.search">>;
+    };
+    builder: {
+      /** Turn an audience description into targeting filters. AI credits apply. (`dench campaign builder autofill`) */
+      autofill(args: Req<"campaigns.builder.autofill">): Promise<Res<"campaigns.builder.autofill">>;
+      /** Start the same billable signal/audience/message build used by the UI; poll the draft for progress. (`dench campaign builder build`) */
+      build(args: Req<"campaigns.builder.build">): Promise<Res<"campaigns.builder.build">>;
+      /** Create a campaign from a reviewed signal draft. Does not launch the campaign. (`dench campaign builder create`) */
+      create(args: Req<"campaigns.builder.create">): Promise<Res<"campaigns.builder.create">>;
+      /** Estimate audience or weekly signal volume using the UI's cached estimator. Provider credits may apply. (`dench campaign builder estimate`) */
+      estimate(args: Req<"campaigns.builder.estimate">): Promise<Res<"campaigns.builder.estimate">>;
+      /** Read signal build progress, preview people, messages and errors. (`dench campaign builder get`) */
+      get(args: Req<"campaigns.builder.get">): Promise<Res<"campaigns.builder.get">>;
+      /** Edit or reset one preview person's opening line before creating the campaign. (`dench campaign builder opener`) */
+      opener(args: Req<"campaigns.builder.opener">): Promise<Res<"campaigns.builder.opener">>;
+      /** Read the company profile and suggested campaign audience. (`dench campaign builder profile`) */
+      profile(args?: Req<"campaigns.builder.profile">): Promise<Res<"campaigns.builder.profile">>;
+      /** Save a signal campaign's audience, signals and terms idempotently. Does not start a build. (`dench campaign builder save`) */
+      save(args: Req<"campaigns.builder.save">): Promise<Res<"campaigns.builder.save">>;
+      /** Suggest signal terms for the selected audience. AI credits apply. (`dench campaign builder terms`) */
+      terms(args: Req<"campaigns.builder.terms">): Promise<Res<"campaigns.builder.terms">>;
+    };
     /** Create a draft outreach campaign with email and LinkedIn sender pools and a business-hours send window in the given timezone. (`dench campaign create`) */
     create(args: Req<"campaigns.create">): Promise<Res<"campaigns.create">>;
+    drafts: {
+      /** Create an idempotent empty campaign draft with the caller's available sender pools. Does not launch or send. (`dench campaign draft`) */
+      create(args: Req<"campaigns.drafts.create">): Promise<Res<"campaigns.drafts.create">>;
+    };
+    /** Copy a campaign into a new draft named "<name> copy": the same steps, schedule, sender pools and personalized lines, its lead source paused, and no people. To reach more than 300 people, duplicate and add the next page of the search to the copy. (`dench campaign duplicate`) */
+    duplicate(args: Req<"campaigns.duplicate">): Promise<Res<"campaigns.duplicate">>;
     /** The campaign's activity log, newest first (sent, accepted, replied, skipped, failed, paused, stopped). (`dench campaign events`) */
     events(args: Req<"campaigns.events">): Promise<Res<"campaigns.events">>;
     /** Read a campaign: settings, steps, people, their current step and hold, last touches, linked leads. (`dench campaign get`) */
@@ -6187,7 +7312,7 @@ export type DenchApiTree = {
       /** Launch a ready draft. Pass the fingerprint from the preview and acknowledge the LinkedIn notice when LinkedIn steps exist. (`dench campaign launch`) */
       (args: Req<"campaigns.launch">): Promise<Res<"campaigns.launch">>;
       $call(args: Req<"campaigns.launch">): Promise<Res<"campaigns.launch">>;
-      /** Launch readiness: blockers grouped by problem, warnings, and the fingerprint `launch` requires. (`dench campaign launch`) */
+      /** Launch readiness without launching: blockers grouped by problem, warnings, and the fingerprint `launch` requires. (`dench campaign launch --check`) */
       preview(args: Req<"campaigns.launch.preview">): Promise<Res<"campaigns.launch.preview">>;
     };
     /** List outreach campaigns (archived ones on request). (`dench campaign list`) */
@@ -6199,18 +7324,68 @@ export type DenchApiTree = {
     people: {
       /** Add one person by email and/or LinkedIn profile URL. (`dench campaign add --name`) */
       add(args: Req<"campaigns.people.add">): Promise<Res<"campaigns.people.add">>;
+      /** Add up to 50 selected recipients without another search. Deduplicates, applies suppression, and preserves the campaign's launch state. (`dench campaign add --people-file`) */
+      addBatch(args: Req<"campaigns.people.addBatch">): Promise<Res<"campaigns.people.addBatch">>;
       /** Add CRM records (up to 100 ids per call) to a campaign; returns how many were added and why others were skipped. (`dench campaign add`) */
       addFromCrm(args: Req<"campaigns.people.addFromCrm">): Promise<Res<"campaigns.people.addFromCrm">>;
+      /** Search and add up to 50 people to an existing campaign. New identities become Leads. Search credits apply; use nextPageToken for another page. (`dench campaign add --search`) */
+      addFromSearch(args: Req<"campaigns.people.addFromSearch">): Promise<Res<"campaigns.people.addFromSearch">>;
+      /** The campaigns a CRM record (a person or a lead) is in, newest first, with the person's status in each and the accounts that send to them. (`dench campaign where`) */
+      forRecord(args: Req<"campaigns.people.forRecord">): Promise<Res<"campaigns.people.forRecord">>;
+      /** Remove a person who was never contacted from a draft campaign. Frees their place in the 300-person cap and keeps the draft launchable; stop anyone already contacted instead. (`dench campaign remove`) */
+      remove(args: Req<"campaigns.people.remove">): Promise<Res<"campaigns.people.remove">>;
       /** Resume one paused person in an active campaign. (`dench campaign resume-person`) */
       resume(args: Req<"campaigns.people.resume">): Promise<Res<"campaigns.people.resume">>;
+      /** Resume every paused person in an active campaign at once, e.g. after a sending account is reconnected. Returns how many were resumed. (`dench campaign resume-person --all`) */
+      resumeAll(args: Req<"campaigns.people.resumeAll">): Promise<Res<"campaigns.people.resumeAll">>;
+      /** Give a person in a draft campaign a new or corrected email address; their linked CRM record gets it too. Only before launch; another person in the campaign can't share it. (`dench campaign person set --email`) */
+      setEmail(args: Req<"campaigns.people.setEmail">): Promise<Res<"campaigns.people.setEmail">>;
+      /** Fill or fix one {{merge field}} for a person in a draft campaign, e.g. a missing Company that blocks launch; a matching column on their CRM record is updated too. Only before launch; written personalized lines are not merge fields and can't be set here. (`dench campaign person set --field`) */
+      setField(args: Req<"campaigns.people.setField">): Promise<Res<"campaigns.people.setField">>;
+      /** Give a person in a draft campaign a new or corrected LinkedIn profile URL; their linked CRM record gets it too. Only before launch. (`dench campaign person set --linkedin-url`) */
+      setLinkedin(args: Req<"campaigns.people.setLinkedin">): Promise<Res<"campaigns.people.setLinkedin">>;
       /** Stop one person: nothing more is sent to them from this campaign. (`dench campaign stop`) */
       stop(args: Req<"campaigns.people.stop">): Promise<Res<"campaigns.people.stop">>;
-    };
+      /** Fill each unfinished person's empty email, LinkedIn URL, name and merge fields from their linked CRM record, e.g. after enriching the records. Never overwrites a value the campaign already has; returns how many people changed. (`dench campaign sync`) */
+      sync(args: Req<"campaigns.people.sync">): Promise<Res<"campaigns.people.sync">>;
+      /** Everything a campaign did for one person, step by step: what was sent (subject and text), whether it was opened or clicked, what was skipped and why, waits, failures and retries. (`dench campaign person show`) */
+      timeline(args: Req<"campaigns.people.timeline">): Promise<Res<"campaigns.people.timeline">>;
+    };
+    personalization: {
+      /** Turn off a campaign's personalized lines and cancel the ones not yet written. Refused while a step still uses one of the {{keys}}. (`dench campaign personalize clear`) */
+      clear(args: Req<"campaigns.personalization.clear">): Promise<Res<"campaigns.personalization.clear">>;
+      /** Set one person's personalized line by hand; an empty value undoes the edit. Braces are removed and text past the line's length is cut. (`dench campaign personalize edit`) */
+      edit(args: Req<"campaigns.personalization.edit">): Promise<Res<"campaigns.personalization.edit">>;
+      /** Read a campaign's personalized lines (written for each person): their {{keys}} for steps, instructions and fallbacks, how many people have them, and the cost per person. (`dench campaign personalize get`) */
+      get(args: Req<"campaigns.personalization.get">): Promise<Res<"campaigns.personalization.get">>;
+      /** Write a fresh personalized line for one person: one key, or all of their lines when key is left out. About 3 cents. (`dench campaign personalize rewrite`) */
+      rewrite(args: Req<"campaigns.personalization.rewrite">): Promise<Res<"campaigns.personalization.rewrite">>;
+      /** Define up to 5 personalized lines (each used as {{key}} in steps) and what you sell. Saving starts writing missing lines for up to 100 people, about 3 cents a person; for more it returns needsConfirm and writes nothing until campaigns.personalization.write is confirmed. (`dench campaign personalize set`) */
+      set(args: Req<"campaigns.personalization.set">): Promise<Res<"campaigns.personalization.set">>;
+      /** Write personalized lines for the people missing them (mode missing) or rewrite everyone's (mode all). Rewriting everyone or more than 100 people returns needsConfirm and the estimate until called with confirmed: true. (`dench campaign personalize write`) */
+      write(args: Req<"campaigns.personalization.write">): Promise<Res<"campaigns.personalization.write">>;
+    };
+    /** Where a campaign's people sit in the workspace's lead pipeline right now: each lead Status in order with how many enrolled leads are at it, and how many have no lead or a status outside the pipeline. (`dench campaign pipeline`) */
+    pipeline(args: Req<"campaigns.pipeline">): Promise<Res<"campaigns.pipeline">>;
+    /** Show the message one person gets at one email or LinkedIn step, with their fields and personalized lines filled in: subject, body, sender, recipient, merge fields still missing, warnings, and why the step would be skipped. Nothing is sent, prepared or charged. (`dench campaign preview`) */
+    preview(args: Req<"campaigns.preview">): Promise<Res<"campaigns.preview">>;
     /** Resume a paused campaign. (`dench campaign resume`) */
     resume(args: Req<"campaigns.resume">): Promise<Res<"campaigns.resume">>;
+    sources: {
+      /** Read a campaign's saved signal source, targeting and schedule. (`dench campaign sources get`) */
+      get(args: Req<"campaigns.sources.get">): Promise<Res<"campaigns.sources.get">>;
+      /** Preview a signal source using its current audience. Provider credits may apply; does not enroll people. (`dench campaign sources preview`) */
+      preview(args: Req<"campaigns.sources.preview">): Promise<Res<"campaigns.sources.preview">>;
+      /** Read signal choices, suggested terms and current source configuration. (`dench campaign sources signals`) */
+      signals(args: Req<"campaigns.sources.signals">): Promise<Res<"campaigns.sources.signals">>;
+      /** Update source cadence, pause/resume, targeting, signals or terms. Active sources may perform billable future work. (`dench campaign sources set`) */
+      update(args: Req<"campaigns.sources.update">): Promise<Res<"campaigns.sources.update">>;
+    };
     steps: {
-      /** Replace every step of a draft campaign (email, wait, LinkedIn visit, connection request, message). Configure sender pools on the campaign; step sender ids are legacy-only. (`dench campaign steps set`) */
+      /** Replace every step of a draft campaign (email, wait, LinkedIn visit, connection request, message, post reaction, InMail). Steps are checked first: a field the step type would drop, missing text or {TOKEN} single braces are rejected, not saved. Configure sender pools on the campaign; step sender ids are legacy-only. (`dench campaign steps set`) */
       replace(args: Req<"campaigns.steps.replace">): Promise<Res<"campaigns.steps.replace">>;
+      /** Edit the text, waits and conditions of a launched (or paused) campaign's steps in place. Each step keeps its id, type and place; pass the stepId and the updatedAt you read, and only the fields you change. Messages already sent or being prepared keep their text; drafts use campaigns.steps.replace. (`dench campaign steps edit`) */
+      update(args: Req<"campaigns.steps.update">): Promise<Res<"campaigns.steps.update">>;
     };
     /** Change a campaign's name, sender pools, send windows, daily email cap, stop-on-reply, start or end. Works until archived; existing conversations keep their assigned sender. (`dench campaign set`) */
     update(args: Req<"campaigns.update">): Promise<Res<"campaigns.update">>;
@@ -6760,7 +7935,7 @@ export type DenchApiTree = {
     generate(args: Req<"image.generate">): Promise<Res<"image.generate">>;
   };
   integrations: {
-    /** List every connected integration — Composio apps plus the Gmail, Outlook, Calendar, LinkedIn and Slack connections Dench brokers itself (Slack rows report source: dench). (`dench integrations`) */
+    /** List every connected integration — connected apps plus the Gmail, Outlook, Calendar, LinkedIn and Slack connections Dench provides itself (Slack rows report source: dench). (`dench integrations`) */
     list(args?: Req<"integrations.list">): Promise<Res<"integrations.list">>;
   };
   lists: {
@@ -6888,7 +8063,7 @@ export type DenchApiTree = {
     };
   };
   tool: {
-    /** Create a tool OAuth connection link. Slack is in-house, never Composio: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. (`dench tool connect`) */
+    /** Create a tool OAuth connection link. Slack is in-house, never a third-party connection: for toolkit slack the CLI prints the first-party install URL (/api/slack/install?slug=<workspace>, org admin) instead of calling this endpoint. (`dench tool connect`) */
     connect(args: Req<"tool.connect">): Promise<Res<"tool.connect">>;
     /** Disconnect an external tool account. (`dench tool disconnect`) */
     disconnect(args: Req<"tool.disconnect">): Promise<Res<"tool.disconnect">>;
@@ -6900,7 +8075,7 @@ export type DenchApiTree = {
       /** List human names given to connected accounts. (`dench tool labels`) */
       list(args?: Req<"tool.labels.list">): Promise<Res<"tool.labels.list">>;
     };
-    /** Run an external tool action. SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through Dench's in-house Slack app install — any channel in the connected workspace — and are always preferred over Composio Slack. (`dench tool run`) */
+    /** Run an external tool action. SLACK_* slugs (SLACK_SEND_MESSAGE with Block Kit blocks/buttons, SLACK_FETCH_HISTORY, SLACK_LIST_CHANNELS, …) run through Dench's in-house Slack app install — any channel in the connected workspace — and are always preferred over any third-party Slack connection. (`dench tool run`) */
     run(args: Req<"tool.run">): Promise<Res<"tool.run">>;
     /** Search for external tool actions. (`dench tool search`) */
     search(args: Req<"tool.search">): Promise<Res<"tool.search">>;
@@ -7278,10 +8453,56 @@ export interface DenchLists {
 }
 
 export interface DenchCampaigns {
+  /** Create a draft campaign. Permission: `campaigns:write`. Wraps `campaigns.create`. */
+  create(opts: Req<"campaigns.create">): Promise<Res<"campaigns.create">>;
+  /** Create an idempotent draft with available sender pools. Permission: `campaigns:write`. Wraps `campaigns.drafts.create`. */
+  draft(opts: Req<"campaigns.drafts.create">): Promise<Res<"campaigns.drafts.create">>;
+  /** Search people without enrolling them. Search credits apply. Permission: `campaigns:write`. Wraps `campaigns.audience.search`. */
+  search(opts: Req<"campaigns.audience.search">): Promise<Res<"campaigns.audience.search">>;
+  /** Add up to 50 selected recipients without running another search. Permission: `campaigns:write`. Wraps `campaigns.people.addBatch`. */
+  addPeople(opts: Req<"campaigns.people.addBatch">): Promise<Res<"campaigns.people.addBatch">>;
+  /** Search and add up to 50 people to an existing campaign. Permission: `campaigns:write`. Wraps `campaigns.people.addFromSearch`. */
+  addFromSearch(opts: Req<"campaigns.people.addFromSearch">): Promise<Res<"campaigns.people.addFromSearch">>;
+  /** Read the campaign's lead source. Permission: `campaigns:read`. Wraps `campaigns.sources.get`. */
+  sources(sequenceId: string): Promise<Res<"campaigns.sources.get">>;
+  /** Read signal choices and suggestions. Permission: `campaigns:read`. Wraps `campaigns.sources.signals`. */
+  sourceSignals(sequenceId: string): Promise<Res<"campaigns.sources.signals">>;
+  /** Update targeting, signals, cadence or source status. Permission: `campaigns:write`. Wraps `campaigns.sources.update`. */
+  updateSources(opts: Req<"campaigns.sources.update">): Promise<Res<"campaigns.sources.update">>;
+  /** Preview a signal without enrolling people. Provider credits may apply. Permission: `campaigns:write`. Wraps `campaigns.sources.preview`. */
+  previewSignal(opts: Req<"campaigns.sources.preview">): Promise<Res<"campaigns.sources.preview">>;
+  /** Read suggested campaign targeting. Permission: `campaigns:read`. Wraps `campaigns.builder.profile`. */
+  profile(): Promise<Res<"campaigns.builder.profile">>;
+  /** Save signal-draft targeting and choices. Permission: `campaigns:write`. Wraps `campaigns.builder.save`. */
+  saveDraft(opts: Req<"campaigns.builder.save">): Promise<Res<"campaigns.builder.save">>;
+  /** Read preview people, messages and build progress. Permission: `campaigns:read`. Wraps `campaigns.builder.get`. */
+  getDraft(draftId: string): Promise<Res<"campaigns.builder.get">>;
+  /** Start a billable signal draft build. Permission: `campaigns:write`. Wraps `campaigns.builder.build`. */
+  buildDraft(draftId: string): Promise<Res<"campaigns.builder.build">>;
+  /** Create a campaign from a reviewed signal draft, without launching. Permission: `campaigns:write`. Wraps `campaigns.builder.create`. */
+  createFromDraft(opts: Req<"campaigns.builder.create">): Promise<Res<"campaigns.builder.create">>;
+  /** Edit a preview person's opening line. Permission: `campaigns:write`. Wraps `campaigns.builder.opener`. */
+  setDraftOpener(opts: Req<"campaigns.builder.opener">): Promise<Res<"campaigns.builder.opener">>;
+  /** Translate a description into targeting. AI credits apply. Permission: `campaigns:write`. Wraps `campaigns.builder.autofill`. */
+  autofill(opts: Req<"campaigns.builder.autofill">): Promise<Res<"campaigns.builder.autofill">>;
+  /** Suggest signal terms. AI credits apply. Permission: `campaigns:write`. Wraps `campaigns.builder.terms`. */
+  suggestTerms(opts: Req<"campaigns.builder.terms">): Promise<Res<"campaigns.builder.terms">>;
+  /** Estimate audience or signal volume. Permission: `campaigns:write`. Wraps `campaigns.builder.estimate`. */
+  estimate(opts: Req<"campaigns.builder.estimate">): Promise<Res<"campaigns.builder.estimate">>;
+  /** Mailboxes campaigns can send from, with warm-up and daily cap. Permission: `campaigns:read`. Wraps `campaigns.accounts.email`. */
+  mailboxes(): Promise<Res<"campaigns.accounts.email">>;
+  /** LinkedIn accounts campaigns can send from, with capacity. Permission: `campaigns:read`. Wraps `campaigns.accounts.linkedin`. */
+  linkedinAccounts(): Promise<Res<"campaigns.accounts.linkedin">>;
   /** LinkedIn / multi-channel outreach campaigns. Permission: `campaigns:read`. Wraps `campaigns.list`. */
   list(): Promise<Res<"campaigns.list">>;
   /** One campaign. Permission: `campaigns:read`. Wraps `campaigns.get`. */
   get(sequenceId: string): Promise<Res<"campaigns.get">>;
+  /** Replace every step of a draft campaign. Permission: `campaigns:write`. Wraps `campaigns.steps.replace`. */
+  setSteps(opts: Req<"campaigns.steps.replace">): Promise<Res<"campaigns.steps.replace">>;
+  /** Edit launched steps in place by stepId and updatedAt. Permission: `campaigns:write`. Wraps `campaigns.steps.update`. */
+  editSteps(opts: Req<"campaigns.steps.update">): Promise<Res<"campaigns.steps.update">>;
+  /** Copy a campaign into a new draft without its people. Permission: `campaigns:write`. Wraps `campaigns.duplicate`. */
+  duplicate(sequenceId: string): Promise<Res<"campaigns.duplicate">>;
   /** Campaign funnel numbers. Permission: `campaigns:read`. Wraps `campaigns.analytics`. */
   analytics(sequenceId: string): Promise<Res<"campaigns.analytics">>;
   /** Campaign event log. Permission: `campaigns:read`. Wraps `campaigns.events`. */
@@ -7290,6 +8511,40 @@ export interface DenchCampaigns {
   pause(sequenceId: string): Promise<Res<"campaigns.pause">>;
   /** Resume a campaign. Permission: `campaigns:write`. Wraps `campaigns.resume`. */
   resume(sequenceId: string): Promise<Res<"campaigns.resume">>;
+  /** Archive (the app's Delete) a campaign; nothing is erased. Permission: `campaigns:write`. Wraps `campaigns.archive`. */
+  archive(sequenceId: string): Promise<Res<"campaigns.archive">>;
+  /** The message one person gets at one step, fields filled in. Sends nothing. Permission: `campaigns:read`. Wraps `campaigns.preview`. */
+  previewMessage(sequenceId: string, enrollmentId: string, stepId: string): Promise<Res<"campaigns.preview">>;
+  /** Personalized lines, their {{keys}} and how many are written. Permission: `campaigns:read`. Wraps `campaigns.personalization.get`. */
+  personalization(sequenceId: string): Promise<Res<"campaigns.personalization.get">>;
+  /** Define up to 5 personalized lines. Writing them costs credits. Permission: `campaigns:write`. Wraps `campaigns.personalization.set`. */
+  setPersonalization(opts: Req<"campaigns.personalization.set">): Promise<Res<"campaigns.personalization.set">>;
+  /** Turn personalized lines off. Permission: `campaigns:write`. Wraps `campaigns.personalization.clear`. */
+  clearPersonalization(sequenceId: string): Promise<Res<"campaigns.personalization.clear">>;
+  /** Write missing (or all) personalized lines. Costs credits. Permission: `campaigns:write`. Wraps `campaigns.personalization.write`. */
+  writeLines(opts: Req<"campaigns.personalization.write">): Promise<Res<"campaigns.personalization.write">>;
+  /** Set one person's personalized line by hand. Permission: `campaigns:write`. Wraps `campaigns.personalization.edit`. */
+  editLine(enrollmentId: string, key: string, value: string): Promise<Res<"campaigns.personalization.edit">>;
+  /** Write a fresh line for one person. Costs credits. Permission: `campaigns:write`. Wraps `campaigns.personalization.rewrite`. */
+  rewriteLine(enrollmentId: string, key?: string): Promise<Res<"campaigns.personalization.rewrite">>;
+  /** Fill people's empty contact details from their CRM records. Permission: `campaigns:write`. Wraps `campaigns.people.sync`. */
+  syncPeople(sequenceId: string): Promise<Res<"campaigns.people.sync">>;
+  /** Resume every paused person in an active campaign. Permission: `campaigns:write`. Wraps `campaigns.people.resumeAll`. */
+  resumeAllPeople(sequenceId: string): Promise<Res<"campaigns.people.resumeAll">>;
+  /** Fix a draft person's email address. Permission: `campaigns:write`. Wraps `campaigns.people.setEmail`. */
+  setPersonEmail(enrollmentId: string, email: string): Promise<Res<"campaigns.people.setEmail">>;
+  /** Fix a draft person's LinkedIn profile URL. Permission: `campaigns:write`. Wraps `campaigns.people.setLinkedin`. */
+  setPersonLinkedin(enrollmentId: string, linkedinProfileUrl: string): Promise<Res<"campaigns.people.setLinkedin">>;
+  /** Fill one {{merge field}} for a draft person. Permission: `campaigns:write`. Wraps `campaigns.people.setField`. */
+  setPersonField(enrollmentId: string, key: string, value: string): Promise<Res<"campaigns.people.setField">>;
+  /** Where the campaign's people sit in the lead pipeline. Permission: `campaigns:read`. Wraps `campaigns.pipeline`. */
+  pipeline(sequenceId: string): Promise<Res<"campaigns.pipeline">>;
+  /** The campaigns a CRM record is in, with its status in each. Permission: `campaigns:read`. Wraps `campaigns.people.forRecord`. */
+  campaignsForRecord(entryId: string): Promise<Res<"campaigns.people.forRecord">>;
+  /** Everything a campaign did for one person, step by step. Permission: `campaigns:read`. Wraps `campaigns.people.timeline`. */
+  personTimeline(enrollmentId: string): Promise<Res<"campaigns.people.timeline">>;
+  /** Remove a never-contacted person from a draft campaign. Permission: `campaigns:write`. Wraps `campaigns.people.remove`. */
+  removePerson(enrollmentId: string): Promise<Res<"campaigns.people.remove">>;
 }
 
 export interface DenchEmail {