conduyt-mcp 4.79.0 → 4.81.0

package/README.md

@@ -15,7 +15,7 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | Tool | Description |
 |------|-------------|
 | `conduyt_list_contacts` | List and search contacts with filters |
-| `conduyt_get_contact` | Get full contact details with timeline |
+| `conduyt_get_contact` | Get full contact details with timeline; `hasOutboundSms` = the workspace has ever provably texted the contact |
 | `conduyt_create_contact` | Create a new contact |
 | `conduyt_update_contact` | Update contact fields; optional `expectedRevision` (0..2147483647) refuses a stale save with 409 `contact_changed` (code + current revision in the error) |
 | `conduyt_add_contact_collaborator` | Add a team member as a collaborator (`POST /contacts/{id}/collaborators`); optional `expectedRevision`, 409 `contact_changed` |
@@ -27,6 +27,8 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 |------|-------------|
 | `conduyt_list_deals` | List deals by pipeline, stage, or assignee; rows carry `hasNextStep` and `nextAppointmentAt`. With `health_summary=true` it answers the Pipeline health strip for the same filtered set (`totalOpenDeals`, `atRiskValue`, `checks[]`, `deals`); `health_check`, `health_limit`, `health_offset`, `health_cursor` (the previous `nextCursor`, passed back unchanged) and `health_rows_only` page one check's deals (rows-only answers `{data:{deals:{check, offset, items, hasMore, nextCursor}}}`) |
 | `conduyt_pipeline_health` | Pipeline health for one pipeline or all visible active pipelines (`GET /deals/inspection`): the six checks over open deals by money at risk; `check` adds that check's deals, paged by `cursor` (or `offset`). Cursor 400s carry `health_cursor_invalid` / `_context` / `_blank` / `_needs_check`, `health_filter_conflict` |
+| `conduyt_pipeline_health_fix_deal` | Pipeline health quick fix for a deal row (`PATCH /deals/{id}` with `checkOrigin`): `stale` = `stageId` (+ `expectedStageId`), `unassigned` = `assignedTo`, `missing_close_date` = `expectedCloseDate`, `missing_contact` = `contactId`; `expectedUpdatedAt` required. Refusals verbatim, never retried: 409 `deal_changed` / `deal_check_cleared` (with the deal's current health row), uncoded 409s, 400 `health_fix_mismatch` |
+| `conduyt_pipeline_health_fix_next_action` | Pipeline health "Set next action" (`POST /tasks` with `checkOrigin` `high_value_idle` / `needs_action`, `dealId`, `expectedDealUpdatedAt`, optional `idempotencyKey` sent as the `Idempotency-Key` header). At most one non-done quick-fix task per deal; refusals verbatim, never retried: 409 `deal_changed` / `deal_has_next_action` / `deal_check_cleared`, 400 `health_fix_mismatch`, idempotency 409/503 |
 | `conduyt_get_stage_rules` / `conduyt_set_stage_rules` | Read / set one stage's rule (`requiredFields` incl. `custom:<fieldKey>`, `requiredDocuments` 0-20, lost-reason label and options, `lostReasonAllowOther`); other stages untouched; revision-aware, retried once on a 409 |
 | `conduyt_get_deal_card_fields` / `conduyt_set_deal_card_fields` | Read / replace the kanban card fields (1-8, built-ins or `custom:<fieldKey>`) |
 | `conduyt_get_settings_revision` | The account `settingsRevision` (plus stored stage rules and rot days): pass it as `expectedSettingsRevision` to `conduyt_archive_pipeline` / `conduyt_delete_stage` so a stale one is refused 409 `stale_settings_revision` |
@@ -108,6 +110,7 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | `conduyt_whatsapp_templates` | The account's WhatsApp templates (Twilio Content) with Meta's approval verdict: sid, text with {{n}} placeholders, variables, approval |
 | `conduyt_send_sms` | Send SMS to a contact (max 1600 chars); transport twilio, project_blue, or whatsapp (an approved template by Content SID, or free-form within the 24-hour window) |
 | `conduyt_send_email` | Send a single email to a contact |
+| `conduyt_check_message` | Grade a draft text or email before sending (`POST /messages/check`): score, grade, verdict, flagged words with safer alternatives (Unicode code-point offsets), checks, a text's segment count. Educates, never blocks; nothing stored or sent. `context` template / first / conversation (pick from `hasOutboundSms`); 20 per minute per account; 400 / 403 / 413 / 429 surfaced verbatim, never retried |
 | `conduyt_log_message` | Record a message on a contact's timeline; an inbound SMS STOP or START records the number's opt-out or opt-in and answers smsConsent |
 
 ### Companies
@@ -166,6 +169,7 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 ### WordPress forms
 | Tool | Description |
 |------|-------------|
+| `conduyt_get_form_intake_status` | Whether any intake address is active and how many (`{ hasActive, activeCount }`, count only, `integrations` scope, read-only) |
 | `conduyt_list_form_intakes` | List the intake addresses: every active one with its full URL, then the revoked history (newest 200) |
 | `conduyt_create_form_intake` | Create an intake address for one Gravity Forms / WPForms / Elementor form (returns its full URL) |
 | `conduyt_revoke_form_intake` | Revoke an intake address (the row is kept for history) |
@@ -332,6 +336,7 @@ The rest of team chat (sending, reactions, pins, presence, uploads) is not wrapp
 |------|-------------|
 | `conduyt_get_lifecycle_settings` | Effective master statuses (defaults + customs) and intake-deals config |
 | `conduyt_update_intake_deals` | Configure automatic deal creation on live intake (webhooks, forms, bookings) |
+| `conduyt_update_booking_creates_own_card` | `settings.bookingCreatesOwnCard`: a booking creates its own card owned by the host instead of reusing the contact's open intake card (strict input; `conduyt_get_lifecycle_settings` reads it) |
 | `conduyt_update_master_statuses` | Set the account's custom lead lifecycle statuses |
 
 ### Reply Capture (inbound email)
@@ -342,6 +347,24 @@ The rest of team chat (sending, reactions, pins, presence, uploads) is not wrapp
 | `conduyt_reply_capture_verify` | Check DNS and promote to live once the provider confirms inbound receiving |
 | `conduyt_reply_capture_remove` | Remove capture (and finish an interrupted removal) — requires `confirm='REMOVE'`; replies to already-sent email are lost |
 
+## Error text grammar
+
+A refused call (HTTP 4xx/5xx) fails the tool with this text, stable across tools:
+
+```
+Conduyt API <status>: <server message>[ [Retry-After: <N>s]][ <details>]
+```
+
+`[Retry-After: Ns]` appears only when the server sent the header (shown, never acted on: a mutation is never retried).
+`<details>` appears only when the body had more than `error`: it is ONE JSON object and the FINAL token. To extract it, try
+each `{` from the left until the rest of the text parses as JSON (a server message may itself contain a brace). The object
+carries scalars first (`code`, revision), then nested objects whole; `HealthFixRefusal.row` is always whole, any other nested
+object too large for the bound is left out and named in `_omitted`. Every HTTP refusal takes this path, including the multipart call-flow audio upload; a tool that adds its own words (a missing-scope or busy note) puts them BEFORE this text. Example:
+
+```
+Conduyt API 503: Contact merge in progress [Retry-After: 5s] {"code":"merge_in_progress"}
+```
+
 ## Setup
 
 ```bash

package/dist/client.d.ts

@@ -28,7 +28,15 @@ export declare class ConduytApiError extends Error {
 export interface RequestOptions {
     timeoutMs?: number;
     maxResponseBytes?: number;
+    /** Extra request headers (e.g. Idempotency-Key on POST /tasks); never overrides Authorization / Content-Type. */
+    headers?: Record<string, string>;
 }
+/**
+ * Render an error body's details (everything but `error`) as ONE valid JSON object: scalars first (code, revision; a very
+ * long string is shortened inside its quotes), then nested objects whole while they fit ERROR_DETAILS_BOUND, plus the
+ * ALWAYS_WHOLE_KEYS; a nested object that does not fit is left out and named in `_omitted`. JSON is never cut mid-object.
+ */
+export declare function renderErrorDetails(body: Record<string, unknown>): string;
 export declare class ConduytClient {
     private baseUrl;
     private apiKey;
@@ -42,7 +50,13 @@ export declare class ConduytClient {
      * after (chunked responses carry no length header).
      */
     private attempt;
+    /**
+     * Error grammar (stable): `Conduyt API <status>: <message>` + optionally ` [Retry-After: <N>s]` + optionally ` <details>`,
+     * where <details> is ONE JSON object and the FINAL token (see renderErrorDetails). Parse it by trying each `{` from the left
+     * until the rest of the text is valid JSON (a server message may itself contain a brace).
+     */
     private httpError;
+    private mkHttpError;
     private retryDelayMs;
     /**
      * Retries are for idempotent GETs ONLY: transient statuses (429/502/503/

package/dist/client.js

@@ -32,6 +32,78 @@ const MAX_RETRY_AFTER_MS = 10_000;
 const isAbort = (err) => err?.name === "TimeoutError" || err?.name === "AbortError";
 /** what a timeout of a MUTATION means: the server may have applied it */
 const AMBIGUOUS = " The server may have applied it: read the current state before repeating it.";
+/** Room for the nested objects of an error body (a 409 contact_changed's `contact`, a stage-requirements list). */
+const ERROR_DETAILS_BOUND = 1000;
+/** Error-body keys that are the actionable state itself and are always rendered WHOLE: HealthFixRefusal.row (the deal's
+ *  current health row, which a caller needs to choose again). The response size cap bounds it. */
+const ALWAYS_WHOLE_KEYS = new Set(["row"]);
+/** Bounded scheme for a refusal's error LISTS (the automation write refusals: AutomationActionConfigKeyError.errors, the 422
+ *  AutomationPreflightRefusal.data { message, errors[], warnings[] }) when they do not fit ERROR_DETAILS_BOUND: keep the first
+ *  MAX_LISTED_ERRORS entries (warnings: MAX_LISTED_WARNINGS) with every string field capped at MAX_FIELD_CHARS, and close the list with
+ *  { "_more": K } for the K entries dropped, so each kept error still carries its code, nodeId, field and suggestion text. */
+const MAX_LISTED_ERRORS = 25;
+const MAX_LISTED_WARNINGS = 10;
+const MAX_FIELD_CHARS = 400;
+const capText = (s) => (s.length > MAX_FIELD_CHARS ? s.slice(0, MAX_FIELD_CHARS) + "...[shortened]" : s);
+const capEntry = (e) => {
+    if (typeof e === "string")
+        return capText(e);
+    if (e && typeof e === "object" && !Array.isArray(e))
+        return Object.fromEntries(Object.entries(e).map(([k, v]) => [k, typeof v === "string" ? capText(v) : v]));
+    return e;
+};
+const capList = (list, max) => [...list.slice(0, max).map(capEntry), ...(list.length > max ? [{ _more: list.length - max }] : [])];
+function compactRefusalList(key, value) {
+    if (key === "errors" && Array.isArray(value))
+        return capList(value, MAX_LISTED_ERRORS);
+    if (key === "data" && value && typeof value === "object" && !Array.isArray(value)) {
+        const d = value;
+        const out = {};
+        for (const [k, v] of Object.entries(d)) {
+            if (k === "message" && typeof v === "string")
+                out[k] = capText(v);
+            else if (k === "errors" && Array.isArray(v))
+                out[k] = capList(v, MAX_LISTED_ERRORS);
+            else if (k === "warnings" && Array.isArray(v))
+                out[k] = capList(v, MAX_LISTED_WARNINGS);
+            else if (v === null || typeof v !== "object")
+                out[k] = v;
+        }
+        return out;
+    }
+    return undefined;
+}
+/**
+ * Render an error body's details (everything but `error`) as ONE valid JSON object: scalars first (code, revision; a very
+ * long string is shortened inside its quotes), then nested objects whole while they fit ERROR_DETAILS_BOUND, plus the
+ * ALWAYS_WHOLE_KEYS; a nested object that does not fit is left out and named in `_omitted`. JSON is never cut mid-object.
+ */
+export function renderErrorDetails(body) {
+    const entries = Object.entries(body).filter(([k]) => k !== "error");
+    if (entries.length === 0)
+        return "";
+    const isScalar = (v) => v === null || typeof v !== "object";
+    const out = {};
+    for (const [k, v] of entries.filter(([, v]) => isScalar(v)))
+        out[k] = typeof v === "string" && v.length > ERROR_DETAILS_BOUND ? v.slice(0, ERROR_DETAILS_BOUND) + "...[shortened]" : v;
+    const omitted = [];
+    for (const [k, v] of entries.filter(([, v]) => !isScalar(v))) {
+        // an EMPTY list / object (the import refusal's `warnings: []`) always fits: it costs two characters and is never "omitted"
+        if (ALWAYS_WHOLE_KEYS.has(k) || JSON.stringify(v).length <= 2 || JSON.stringify({ ...out, [k]: v }).length <= ERROR_DETAILS_BOUND)
+            out[k] = v;
+        else {
+            // a refusal's error list never vanishes into `_omitted`: it is kept in the bounded scheme above (codes and suggestions intact)
+            const compact = compactRefusalList(k, v);
+            if (compact !== undefined)
+                out[k] = compact;
+            else
+                omitted.push(k);
+        }
+    }
+    if (omitted.length > 0)
+        out._omitted = omitted;
+    return JSON.stringify(out);
+}
 export class ConduytClient {
     baseUrl;
     apiKey;
@@ -63,9 +135,10 @@ export class ConduytClient {
      * from Content-Length before the body is read AND from the actual bytes
      * after (chunked responses carry no length header).
      */
-    async attempt(method, path, body, timeoutMs, maxResponseBytes) {
+    async attempt(method, path, body, timeoutMs, maxResponseBytes, extraHeaders) {
         const url = `${this.baseUrl}${path}`;
         const headers = {
+            ...(extraHeaders ?? {}),
             Authorization: `Bearer ${this.apiKey}`,
             "Content-Type": "application/json",
         };
@@ -161,36 +234,40 @@ export class ConduytClient {
         }
         return { res, text };
     }
+    /**
+     * Error grammar (stable): `Conduyt API <status>: <message>` + optionally ` [Retry-After: <N>s]` + optionally ` <details>`,
+     * where <details> is ONE JSON object and the FINAL token (see renderErrorDetails). Parse it by trying each `{` from the left
+     * until the rest of the text is valid JSON (a server message may itself contain a brace).
+     */
     httpError(res, text) {
+        const retryAfterRaw = res.headers.get("retry-after");
+        const retryAfter = retryAfterRaw === null || retryAfterRaw.trim() === "" ? NaN : Number(retryAfterRaw);
+        const retryAfterOk = Number.isFinite(retryAfter) && retryAfter >= 0;
+        const raTag = retryAfterOk ? ` [Retry-After: ${retryAfter}s]` : "";
         let msg = res.statusText;
         try {
             const json = JSON.parse(text);
             if (json?.error)
                 msg = json.error;
-            // Structured error details (e.g. STAGE_REQUIREMENTS carries
-            // lostReasonOptions) must reach the agent, or a "must be one of the
-            // configured options" error is unactionable. Bounded so a pathological
-            // body can't bloat the message.
-            // Scalars first (code, revision), nested objects last (a 409 contact_changed carries the whole current
-            // `contact`): the bound below may cut a large object, never the code or the current revision.
-            const isScalar = (v) => v === null || typeof v !== "object";
-            const entries = Object.entries(json ?? {}).filter(([k]) => k !== "error");
-            const details = Object.fromEntries([
-                ...entries.filter(([, v]) => isScalar(v)),
-                ...entries.filter(([, v]) => !isScalar(v)),
-            ]);
-            if (Object.keys(details).length > 0) {
-                msg = `${msg} ${JSON.stringify(details).slice(0, 1000)}`;
-            }
+            // Structured error details (e.g. STAGE_REQUIREMENTS carries lostReasonOptions) must reach the agent, or the
+            // refusal is unactionable. Rendered by renderErrorDetails: JSON is never cut mid-object.
+            const details = renderErrorDetails(json ?? {});
+            if (details)
+                msg = `${msg}${raTag} ${details}`;
+            else
+                msg = `${msg}${raTag}`;
+            return this.mkHttpError(res, `Conduyt API ${res.status}: ${msg}`, retryAfter, retryAfterOk);
         }
         catch {
             if (text)
                 msg = text.slice(0, 500);
+            msg = `${msg}${raTag}`;
         }
-        const retryAfterRaw = res.headers.get("retry-after");
-        const retryAfter = retryAfterRaw === null || retryAfterRaw.trim() === "" ? NaN : Number(retryAfterRaw);
+        return this.mkHttpError(res, `Conduyt API ${res.status}: ${msg}`, retryAfter, retryAfterOk);
+    }
+    mkHttpError(res, message, retryAfter, retryAfterOk) {
         return new ConduytApiError({
-            message: `Conduyt API ${res.status}: ${msg}`,
+            message,
             status: res.status,
             code: "http",
             retryable: RETRYABLE_STATUSES.has(res.status),
@@ -224,7 +301,7 @@ export class ConduytClient {
             const remaining = totalBudgetMs - (Date.now() - startedAt);
             let res = null;
             try {
-                const out = await this.attempt(method, path, body, Math.max(1, Math.min(timeoutMs, remaining)), maxResponseBytes);
+                const out = await this.attempt(method, path, body, Math.max(1, Math.min(timeoutMs, remaining)), maxResponseBytes, opts?.headers);
                 res = out.res;
                 if (out.res.ok)
                     return out.text;
@@ -282,10 +359,9 @@ export class ConduytClient {
         catch {
             json = { raw: text };
         }
-        if (!res.ok) {
-            const msg = json?.error ?? text.slice(0, 300);
-            throw new ConduytApiError({ message: `Conduyt API ${res.status}: ${msg}`, status: res.status, code: "http", retryable: res.status >= 500 });
-        }
+        // every non-2xx goes through the shared formatter: same grammar, Retry-After placement and final JSON details object
+        if (!res.ok)
+            throw this.httpError(res, text);
         return json;
     }
     post(path, body, opts) {

package/dist/tools/action-config-typos.d.ts

@@ -0,0 +1,11 @@
+export type ActionConfigTypo = {
+    actionType: string;
+    key: string;
+    suggestion: string;
+};
+/** The first misspelled option key in an actions graph (v1 array of {type, config}, or v2 { nodes: [{ action: {type, config} }] }), or null */
+export declare function findActionConfigTypo(graph: unknown): ActionConfigTypo | null;
+/** The refusal text; the details object is the final token */
+export declare function actionConfigTypoMessage(t: ActionConfigTypo): string;
+/** Throws (a plain Error) when the graph carries a misspelled option */
+export declare function assertNoActionConfigTypo(graph: unknown): void;

package/dist/tools/action-config-typos.js

@@ -0,0 +1,78 @@
+/**
+ * Local typo guard for automation action configs (card ownership per lane, Codex r1/r2). The server validator is the authority
+ * and there the option names are not enforced yet, so a typoed `laneSoruce` on assign_to_user would silently assign the run's
+ * deal instead of the lane card. Only the options below are known here.
+ *
+ * Traversal rule: ONLY the real action positions of the graph are visited, exactly as the graph is shaped: a v1 `actions`
+ * array's elements `{type, config}`, and a v2 graph's `nodes[].action` `{type, config}`. For each action of a known type the
+ * IMMEDIATE keys of `config` are checked; the config VALUES are opaque and never descended into (a webhook payload may hold any
+ * object, including one shaped like an action), and nothing outside those positions (request metadata, other node fields) is
+ * scanned. A key that is not a known option but is a case-insensitive match or ONE edit (substitution, insertion, deletion or
+ * adjacent transposition) from one is refused; keys further away, and every other action type, pass through.
+ * Source of the names: lib/automation-action-registry.ts in the app (assign_to_user, create_deal, close_other_open_deals).
+ */
+const KNOWN_ACTION_OPTIONS = {
+    assign_to_user: ["runWindow", "mode", "userId", "userIds", "groupId", "target", "applyTo", "overwriteExisting", "laneSource", "lanePipelineId", "laneStageId"],
+    create_deal: ["pipelineId", "stageId", "dealName", "dealValue", "allowDuplicates", "status", "source", "assignedTo", "leaveUnassigned"],
+    close_other_open_deals: ["lostReason"],
+};
+/** Damerau-Levenshtein (optimal string alignment) distance, case-insensitive */
+function distance(a, b) {
+    const x = a.toLowerCase(), y = b.toLowerCase();
+    const d = Array.from({ length: x.length + 1 }, (_, i) => [i, ...Array(y.length).fill(0)]);
+    for (let j = 1; j <= y.length; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= x.length; i++) {
+        for (let j = 1; j <= y.length; j++) {
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (x[i - 1] === y[j - 1] ? 0 : 1));
+            if (i > 1 && j > 1 && x[i - 1] === y[j - 2] && x[i - 2] === y[j - 1])
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+        }
+    }
+    return d[x.length][y.length];
+}
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function checkAction(action) {
+    if (!isObject(action) || typeof action.type !== "string" || !isObject(action.config))
+        return null;
+    const known = KNOWN_ACTION_OPTIONS[action.type];
+    if (!known)
+        return null;
+    for (const key of Object.keys(action.config)) {
+        if (known.includes(key))
+            continue;
+        const near = known.find((k) => distance(key, k) <= 1);
+        if (near)
+            return { actionType: action.type, key, suggestion: near };
+    }
+    return null;
+}
+/** The first misspelled option key in an actions graph (v1 array of {type, config}, or v2 { nodes: [{ action: {type, config} }] }), or null */
+export function findActionConfigTypo(graph) {
+    if (Array.isArray(graph)) {
+        for (const action of graph) {
+            const t = checkAction(action);
+            if (t)
+                return t;
+        }
+        return null;
+    }
+    if (isObject(graph) && Array.isArray(graph.nodes)) {
+        for (const node of graph.nodes) {
+            const t = isObject(node) ? checkAction(node.action) : null;
+            if (t)
+                return t;
+        }
+    }
+    return null;
+}
+/** The refusal text; the details object is the final token */
+export function actionConfigTypoMessage(t) {
+    return `Unknown option "${t.key}" in ${t.actionType} config: did you mean "${t.suggestion}"? Nothing was sent. ${JSON.stringify(t)}`;
+}
+/** Throws (a plain Error) when the graph carries a misspelled option */
+export function assertNoActionConfigTypo(graph) {
+    const t = findActionConfigTypo(graph);
+    if (t)
+        throw new Error(actionConfigTypoMessage(t));
+}

package/dist/tools/automations.d.ts

@@ -1,3 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ConduytClient } from "../client.js";
+/** (card ownership per lane, app 10-08/09) the action options an agent can set; the catalog does not carry action config, so this is the one place they are documented */
+export declare const CARD_OWNERSHIP_ACTIONS_NOTE = " Card ownership per lane: assign_to_user config {userId | userIds (round robin) | groupId, target|applyTo: contact|deal|both, overwriteExisting, laneSource, lanePipelineId, laneStageId}: laneSource names a card lane (the Deal.source its Auto-Create step wrote, e.g. 'GSM', max 500 chars) and makes the deal leg assign the contact's newest OPEN card from that lane (inside lanePipelineId when set) instead of the run's deal; when the contact has none and lanePipelineId is set, the card is created there (laneStageId, else the pipeline's first stage) already owned by the user; lanePipelineId or laneStageId without laneSource, or laneStageId without lanePipelineId, is refused; a lane never applies to an 'Assign to: contact' step. create_deal config {pipelineId (required), stageId, dealName, dealValue, allowDuplicates, status, source, assignedTo, leaveUnassigned}: leaveUnassigned true leaves the card unassigned when no assignee is set (default false: the card goes to the lead's owner). close_other_open_deals config {lostReason (required)}: closes the contact's OTHER open cards as lost with that reason, keeping the run's own card (each moves to its pipeline's lost stage with the usual stage-change effects; cards already won/lost, in the DPP Post-Close pipeline or in a pipeline with no lost stage are skipped; a re-run closes nothing twice); it needs the run's own deal, so use a deal trigger or a find_opportunity step first.";
+/** (#124, automation unknown keys / types) the refusal codes the write paths answer; surfaced verbatim by the client (details JSON object last), never retried */
+export declare const AUTOMATION_KEY_REFUSALS_NOTE = " Unknown action keys are refused, never ignored: an action config key the action does not read (a typo such as `laneSoruce`) answers code `unknown_action_config_key` with the node, the key and, when one is close, a suggestion (\"Did you mean `laneSource`?\"); an action `type` no registry entry defines answers `unknown_action_type` (with 'Did you mean' when a registered type is close). Create and update answer 400 (an update that does not write `actions` is never refused for a key stored earlier), conduyt_workflow_validate answers 200 with valid false and the `errors` list (nodeId, field, code, message), and publish / a version restore answer 422 (the preflight refusal wraps `data.message`, `data.errors`, `data.warnings`). Read the suggestion, fix the key and send again; a stored workflow is never refused on read.";
+/** GET /automations/:id answers { data: { ...automation, configRevision } } (jsonResponse wraps): the revision lives under `data` */
+export declare function configRevisionOf(raw: unknown): number | undefined;
 export declare function registerAutomationTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/automations.js

@@ -1,5 +1,15 @@
 import { z } from "zod";
-import { formatResult } from "../client.js";
+import { formatResult, formatToolError } from "../client.js";
+/** (card ownership per lane, app 10-08/09) the action options an agent can set; the catalog does not carry action config, so this is the one place they are documented */
+export const CARD_OWNERSHIP_ACTIONS_NOTE = " Card ownership per lane: assign_to_user config {userId | userIds (round robin) | groupId, target|applyTo: contact|deal|both, overwriteExisting, laneSource, lanePipelineId, laneStageId}: laneSource names a card lane (the Deal.source its Auto-Create step wrote, e.g. 'GSM', max 500 chars) and makes the deal leg assign the contact's newest OPEN card from that lane (inside lanePipelineId when set) instead of the run's deal; when the contact has none and lanePipelineId is set, the card is created there (laneStageId, else the pipeline's first stage) already owned by the user; lanePipelineId or laneStageId without laneSource, or laneStageId without lanePipelineId, is refused; a lane never applies to an 'Assign to: contact' step. create_deal config {pipelineId (required), stageId, dealName, dealValue, allowDuplicates, status, source, assignedTo, leaveUnassigned}: leaveUnassigned true leaves the card unassigned when no assignee is set (default false: the card goes to the lead's owner). close_other_open_deals config {lostReason (required)}: closes the contact's OTHER open cards as lost with that reason, keeping the run's own card (each moves to its pipeline's lost stage with the usual stage-change effects; cards already won/lost, in the DPP Post-Close pipeline or in a pipeline with no lost stage are skipped; a re-run closes nothing twice); it needs the run's own deal, so use a deal trigger or a find_opportunity step first.";
+/** (#124, automation unknown keys / types) the refusal codes the write paths answer; surfaced verbatim by the client (details JSON object last), never retried */
+export const AUTOMATION_KEY_REFUSALS_NOTE = " Unknown action keys are refused, never ignored: an action config key the action does not read (a typo such as `laneSoruce`) answers code `unknown_action_config_key` with the node, the key and, when one is close, a suggestion (\"Did you mean `laneSource`?\"); an action `type` no registry entry defines answers `unknown_action_type` (with 'Did you mean' when a registered type is close). Create and update answer 400 (an update that does not write `actions` is never refused for a key stored earlier), conduyt_workflow_validate answers 200 with valid false and the `errors` list (nodeId, field, code, message), and publish / a version restore answer 422 (the preflight refusal wraps `data.message`, `data.errors`, `data.warnings`). Read the suggestion, fix the key and send again; a stored workflow is never refused on read.";
+/** GET /automations/:id answers { data: { ...automation, configRevision } } (jsonResponse wraps): the revision lives under `data` */
+export function configRevisionOf(raw) {
+    const row = raw && typeof raw === "object" && "data" in raw ? raw.data : raw;
+    const rev = row?.configRevision;
+    return typeof rev === "number" ? rev : undefined;
+}
 export function registerAutomationTools(server, client) {
     server.tool("conduyt_list_automations", "List all automations (workflows) in the account. Returns name, trigger event, status, and execution counts.", {
         page: z.number().optional().describe("Page number (default 1)"),
@@ -19,14 +29,14 @@ export function registerAutomationTools(server, client) {
         const result = await client.get(`/api/v1/automations/${id}`);
         return formatResult(result);
     });
-    server.tool("conduyt_create_automation", "Create a new automation. Requires a name and trigger event. Use conduyt_resolve_names to convert human-readable names to UUIDs before building actions.", {
+    server.tool("conduyt_create_automation", "Create a new automation. Requires a name and trigger event. Use conduyt_resolve_names to convert human-readable names to UUIDs before building actions." + AUTOMATION_KEY_REFUSALS_NOTE, {
         name: z.string().describe("Automation name"),
         description: z.string().optional().describe("Description of what this automation does"),
         triggerEvent: z.string().describe("Trigger event (e.g. 'contact.created', 'deal.stage_changed', 'tag.added', 'scheduled', or 'message.understood' — fires when the copilot has read an inbound text/email and understood its intent; list them all with conduyt_list_automation_events)"),
         kind: z.enum(["native", "n8n"]).optional().describe("Automation type — 'native' for the built-in graph engine (use `actions`), 'n8n' for an external n8n webhook (requires n8nWorkflowId + n8nWebhookUrl). For agent-built automations use 'native'."),
         n8nWorkflowId: z.string().optional().describe("n8n workflow ID (required when kind='n8n')"),
         n8nWebhookUrl: z.string().optional().describe("n8n webhook URL (required when kind='n8n')"),
-        actions: z.any().optional().describe("Actions graph — v1: [{type, config}], v2: {nodes:[], startNodeId}. A sequence step is the action enroll_in_sequence with config {sequenceId, enrollAction: 'add' (default) | 'remove'}: add puts the contact into the sequence (the sequence must allow automation enrollment, allowAutomationEnroll), remove ends their run. A delay node waits for a fixed duration by default; waitType 'until_field_date' (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately)."),
+        actions: z.any().optional().describe("Actions graph — v1: [{type, config}], v2: {nodes:[], startNodeId}. A sequence step is the action enroll_in_sequence with config {sequenceId, enrollAction: 'add' (default) | 'remove'}: add puts the contact into the sequence (the sequence must allow automation enrollment, allowAutomationEnroll), remove ends their run. A delay node waits for a fixed duration by default; waitType 'until_field_date' (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately)." + CARD_OWNERSHIP_ACTIONS_NOTE + ""),
         graphVersion: z.number().optional().describe("Graph version — 1 (legacy array) or 2 (node graph). Default 1"),
         schedule: z.string().optional().describe("5-field cron expression (required if triggerEvent='scheduled')"),
         scheduleTimezone: z.string().optional().describe("IANA timezone for scheduled triggers (e.g. 'America/Los_Angeles')"),
@@ -38,7 +48,7 @@ export function registerAutomationTools(server, client) {
         const result = await client.post("/api/v1/automations", params);
         return formatResult(result);
     });
-    server.tool("conduyt_update_automation", "Update an existing automation — change trigger, actions, schedule, or activation status.", {
+    server.tool("conduyt_update_automation", "Update an existing automation — change trigger, actions, schedule, or activation status." + AUTOMATION_KEY_REFUSALS_NOTE, {
         id: z.string().describe("Automation UUID"),
         name: z.string().optional().describe("Updated name"),
         description: z.string().optional().describe("Updated description"),
@@ -48,7 +58,8 @@ export function registerAutomationTools(server, client) {
             .optional()
             .describe("Updated trigger conditions (replaces the object). Same keys as create — e.g. { untouchedDays: 7 } on 'contact.untouched'. (#16 tri-surface parity: the UI and API could set this; MCP could not.)"),
         isActive: z.boolean().optional().describe("Enable or disable the automation"),
-        actions: z.any().optional().describe("Updated actions graph (same shape as create; e.g. enroll_in_sequence {sequenceId, enrollAction: 'add' | 'remove'}) A delay node waits for a fixed duration by default; waitType 'until_field_date' (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately)."),
+        expectedConfigRevision: z.number().int().nonnegative().optional().describe("REQUIRED whenever `actions` is replaced: the configRevision of the automation you read (conduyt_get_automation) before preparing the new graph. It is sent unchanged; if the automation was saved since, the API answers 409 with the current revision and nothing is overwritten, so re-read, re-apply your change and call again. Not needed for an update that leaves `actions` alone"),
+        actions: z.any().optional().describe("Updated actions graph (same shape as create; e.g. enroll_in_sequence {sequenceId, enrollAction: 'add' | 'remove'}) A delay node waits for a fixed duration by default; waitType 'until_field_date' (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately)." + CARD_OWNERSHIP_ACTIONS_NOTE + ""),
         schedule: z.string().optional().describe("Updated cron schedule"),
         scheduleTimezone: z.string().optional().describe("Updated timezone"),
         stopOnResponse: z.boolean().optional().describe("Stop drip if contact responds"),
@@ -57,18 +68,15 @@ export function registerAutomationTools(server, client) {
             .optional()
             .describe("What a NEW trigger does when the contact is already mid-sequence: 'keep' (default — skip, existing run keeps its schedule) or 'restart' (cancel the parked run and re-enroll from step 1)"),
     }, async ({ id, ...updates }) => {
-        // (Conduyt Sentry r58–r60 parity) a save that replaces the actions of a LIVE workflow must carry the
-        // configRevision it was based on — fetch it first so the server can refuse a stale overwrite (409)
-        let body = updates;
-        if (updates.actions !== undefined && body.expectedConfigRevision === undefined) {
-            const current = (await client.get(`/api/v1/automations/${id}`));
-            if (typeof current?.configRevision === "number")
-                body = { ...body, expectedConfigRevision: current.configRevision };
+        // (Codex r5) replacing the actions must be bound to the revision the CALLER read before preparing the graph: a revision fetched
+        // here would be whatever is newest, so a concurrent save between the caller's read and this call would be silently overwritten
+        if (updates.actions !== undefined && updates.expectedConfigRevision === undefined) {
+            return formatToolError("Replacing `actions` needs expectedConfigRevision: read the automation first (conduyt_get_automation) and pass its configRevision. Nothing was sent.");
         }
-        const result = await client.patch(`/api/v1/automations/${id}`, body);
+        const result = await client.patch(`/api/v1/automations/${id}`, updates);
         return formatResult(result);
     });
-    server.tool("conduyt_publish_automation", "Publish an automation — copies the draft actions to the live published version. The automation must have actions defined. The publish is bound to the draft revision you reviewed (fetched automatically unless you pass expectedConfigRevision).", {
+    server.tool("conduyt_publish_automation", "Publish an automation — copies the draft actions to the live published version. The automation must have actions defined. The publish is bound to the draft revision you reviewed (fetched automatically unless you pass expectedConfigRevision)." + AUTOMATION_KEY_REFUSALS_NOTE, {
         id: z.string().describe("Automation UUID"),
         expectedConfigRevision: z.number().int().nonnegative().optional().describe("The configRevision of the draft you reviewed (from conduyt_get_automation); fetched automatically when omitted"),
     }, async ({ id, expectedConfigRevision }) => {
@@ -76,8 +84,7 @@ export function registerAutomationTools(server, client) {
         // review is refused (409) instead of going live unreviewed
         let revision = expectedConfigRevision;
         if (revision === undefined) {
-            const current = (await client.get(`/api/v1/automations/${id}`));
-            revision = typeof current?.configRevision === "number" ? current.configRevision : undefined;
+            revision = configRevisionOf(await client.get(`/api/v1/automations/${id}`));
         }
         const result = await client.post(`/api/v1/automations/${id}/publish`, { expectedConfigRevision: revision });
         return formatResult(result);

package/dist/tools/contacts.js

@@ -51,7 +51,7 @@ export function registerContactTools(server, client) {
         const result = await client.get(`/api/v1/contacts?${params}`);
         return formatResult(result);
     });
-    server.tool("conduyt_get_contact", "Get a single contact with full details — profile, tags, custom fields, timeline, deals, and activity history. Includes `revision` (integer save revision): pass it as expectedRevision on conduyt_update_contact or the collaborator tools so a newer change is never overwritten.", {
+    server.tool("conduyt_get_contact", "Get a single contact with full details — profile, tags, custom fields, timeline, deals, and activity history. Includes `revision` (integer save revision): pass it as expectedRevision on conduyt_update_contact or the collaborator tools so a newer change is never overwritten. Includes `hasOutboundSms` (boolean): true when this workspace has ever PROVABLY texted the contact (a proven send only: not a draft, a queued row or a pre-send failure); use it to pick the `context` for conduyt_check_message (false = 'first', true = 'conversation').", {
         id: z.string().describe("Contact UUID"),
     }, async ({ id }) => {
         const result = await client.get(`/api/v1/contacts/${id}`);

package/dist/tools/deals.js

@@ -112,6 +112,35 @@ export function registerDealTools(server, client) {
         const result = qs ? await client.get("/api/v1/deals/inspection?" + qs) : await client.get("/api/v1/deals/inspection");
         return formatResult(result);
     }));
+    strictInput(server.tool("conduyt_pipeline_health_fix_deal", "Pipeline health QUICK FIX for a deal row (PATCH /api/v1/deals/{id} with checkOrigin). Pass the health check the row came from, the deal's updatedAt exactly as the health row carried it (expectedUpdatedAt, REQUIRED), and ONLY that check's fix: stale = stageId (+ optional expectedStageId, the stage the move was chosen against); unassigned = assignedTo; missing_close_date = expectedCloseDate; missing_contact = contactId. Each set to a value; any other combination is refused 400 health_fix_mismatch and nothing is read or written. For the next-action checks (high_value_idle, needs_action) use conduyt_pipeline_health_fix_next_action instead. Refusals reach you verbatim (status, server message, code, and the deal's CURRENT health row) and are NEVER retried. Error text grammar: `Conduyt API <status>: <message>[ [Retry-After: Ns]][ <one JSON object, the final token>]` (see README, Error text grammar). 409 deal_changed (the deal is no longer at expectedUpdatedAt; error text carries updatedAt and the current row: read it, choose again against row.updatedAt), 409 deal_check_cleared (the deal no longer fails that check; nothing written), a 409 without a code (a stage move by another writer, a stale expectedStageId, an in-flight publication), 400 health_fix_mismatch, 404 (no such deal, or your key cannot see it). The row in a refusal is null when your key can no longer see the deal. Ordinary edits (several fields, no health context) stay on conduyt_update_deal.", {
+        dealId: z.string().uuid().describe("Deal UUID"),
+        checkOrigin: z.enum(["stale", "unassigned", "missing_close_date", "missing_contact"]).describe("The health check this edit fixes"),
+        expectedUpdatedAt: z.string().datetime({ message: "expectedUpdatedAt must be the deal's updatedAt exactly as the health row carried it (UTC, trailing Z, e.g. 2026-10-06T23:19:00.000Z)" }).describe("REQUIRED: the deal's updatedAt as the health row carried it (PipelineHealthDeal.updatedAt). A deal at another version is refused 409 deal_changed."),
+        stageId: z.string().uuid().optional().describe("stale only: the stage to move the deal to"),
+        expectedStageId: z.string().uuid().optional().describe("stale only: the stage the move was chosen against; refused 409 (nothing written) when the deal is no longer in it"),
+        assignedTo: z.string().uuid().optional().describe("unassigned only: the user (owner) UUID to assign"),
+        expectedCloseDate: z.string().optional().describe("missing_close_date only: the expected close date (ISO 8601, e.g. '2026-11-30')"),
+        contactId: z.string().uuid().optional().describe("missing_contact only: the contact UUID to link"),
+    }, async ({ dealId, checkOrigin, expectedUpdatedAt, stageId, expectedStageId, assignedTo, expectedCloseDate, contactId }) => {
+        const result = await client.patch(`/api/v1/deals/${dealId}`, { checkOrigin, expectedUpdatedAt, stageId, expectedStageId, assignedTo, expectedCloseDate, contactId });
+        return formatResult(result);
+    }));
+    strictInput(server.tool("conduyt_pipeline_health_fix_next_action", "Pipeline health QUICK FIX \"Set next action\" (POST /api/v1/tasks with checkOrigin): creates a follow-up task on a deal from the High-value idle or Needs next action row. Pass checkOrigin, dealId and expectedDealUpdatedAt (the deal's updatedAt as the health row carried it); the task is created only while, under the deal's next-action lock, the deal is still at that version, still has no next action (no open task, no appointment booked from a day ago on) and still fails the check. Send idempotencyKey (1-255 printable ASCII) so a retry after a lost response replays the first task; reuse it ONLY for the same request. Refusals reach you verbatim (status, message, code, the deal's CURRENT health row) and are NEVER retried. Error text grammar: `Conduyt API <status>: <message>[ [Retry-After: Ns]][ <one JSON object, the final token>]` (see README, Error text grammar). 409 deal_changed (read the row, choose again against row.updatedAt), 409 deal_has_next_action (This deal already has a next action booked.), 409 deal_check_cleared, 400 health_fix_mismatch (checkOrigin not high_value_idle / needs_action, or without dealId / expectedDealUpdatedAt), a 409 without a code (the contact was merged or deleted mid-request: retry against the surviving record), or an idempotency 409/503 (see the idempotencyKey notes; verify the outcome before using a new key). The database allows at most one non-done quick-fix task per deal (a second is refused 409 deal_has_next_action); ordinary tasks (conduyt_create_task) are unconstrained and may coexist with or race a quick fix.", {
+        checkOrigin: z.enum(["high_value_idle", "needs_action"]).describe("The health check this task fixes"),
+        dealId: z.string().uuid().describe("Deal UUID the task is for"),
+        expectedDealUpdatedAt: z.string().datetime({ message: "expectedDealUpdatedAt must be the deal's updatedAt exactly as the health row carried it (UTC, trailing Z)" }).describe("REQUIRED: the deal's updatedAt as the health row carried it (PipelineHealthDeal.updatedAt)"),
+        title: z.string().min(1).max(500).describe("Task title (trimmed; blank is refused)"),
+        description: z.string().max(5000).optional().describe("Task description (max 5000)"),
+        dueDate: z.string().optional().describe("Due date: a date-only YYYY-MM-DD is stored as noon UTC that day; a date-time as given"),
+        priority: z.enum(["low", "medium", "high", "urgent"]).optional().describe("Task priority (default medium)"),
+        status: z.enum(["todo", "in_progress", "done"]).optional().describe("Task status (default todo)"),
+        assignedTo: z.string().nullable().optional().describe("A member's user UUID, '@me' or '@owner'; null or omitted = unassigned (assignment rules may still assign it). Assigning to someone else needs tasks.assign."),
+        contactId: z.string().uuid().nullable().optional().describe("Contact UUID to link"),
+        idempotencyKey: z.string().regex(/^[!-~](?:[ -~]{0,253}[!-~])?$/, "idempotencyKey must be 1-255 printable ASCII characters, not blank").optional().describe("Sent as the Idempotency-Key header: one key per creation attempt, reused only to retry the SAME request (same key + same body replays the first task; same key + a different body is 422). Two distinct 409s: the original attempt is still processing (wait Retry-After, retry with the SAME key), or code idempotency_key_spent (a prior attempt failed or has an unknown outcome: verify whether it took effect BEFORE a new key). 503 idempotency_claim_held: retry with a NEW key; 503 idempotency_outcome_unknown: verify the outcome first."),
+    }, async ({ idempotencyKey, checkOrigin, dealId, expectedDealUpdatedAt, title, description, dueDate, priority, status, assignedTo, contactId }) => {
+        const result = await client.post("/api/v1/tasks", { checkOrigin, dealId, expectedDealUpdatedAt, title, description, dueDate, priority, status, assignedTo, contactId }, idempotencyKey !== undefined ? { headers: { "Idempotency-Key": idempotencyKey } } : undefined);
+        return formatResult(result);
+    }));
     server.tool("conduyt_get_deal", "Get a single deal with full details — value, currency, probability, stage, contact, expected close date, custom-field values, activities, tasks, and history. Use this to read structured custom-field data back out of a deal (e.g. for a P&L or balance-sheet model). Deal rows also carry hasNextStep and nextAppointmentAt (null unless your key can view the calendar) when the API returns them.", {
         id: z.string().describe("Deal UUID"),
     }, async ({ id }) => {

package/dist/tools/form-intakes.d.ts

@@ -10,8 +10,10 @@ import { ConduytClient } from "../client.js";
  */
 /** What each tool's key must hold: the API names only the FIRST missing scope, so a 403 is surfaced with all of it. */
 export declare const LIST_AND_CREATE_REQUIREMENT = "the form-intakes AND contacts scopes on a write or admin tier key (a member: settings.edit, contacts.create and contacts.edit)";
+export declare const STATUS_REQUIREMENT = "the integrations scope (read-only; a member: settings.view)";
 export declare const REVOKE_REQUIREMENT = "the form-intakes scope on an admin tier key (a member: settings.edit)";
-/** A 403 names the complete requirement; a busy 503 says when to retry (never replayed here: create is a mutation). */
+/** A 403 names the complete requirement; a busy 503 says when to retry (never replayed here: create is a mutation). Annotations go BEFORE the
+ *  client's message, so its details JSON object stays the final token (README, Error text grammar). */
 export declare function intakeToolError(err: unknown, requirement: string): {
     content: Array<{
         type: "text";

package/dist/tools/form-intakes.js

@@ -10,19 +10,32 @@ import { ConduytApiError, formatResult, formatToolError } from "../client.js";
  */
 /** What each tool's key must hold: the API names only the FIRST missing scope, so a 403 is surfaced with all of it. */
 export const LIST_AND_CREATE_REQUIREMENT = "the form-intakes AND contacts scopes on a write or admin tier key (a member: settings.edit, contacts.create and contacts.edit)";
+export const STATUS_REQUIREMENT = "the integrations scope (read-only; a member: settings.view)";
 export const REVOKE_REQUIREMENT = "the form-intakes scope on an admin tier key (a member: settings.edit)";
-/** A 403 names the complete requirement; a busy 503 says when to retry (never replayed here: create is a mutation). */
+/** A 403 names the complete requirement; a busy 503 says when to retry (never replayed here: create is a mutation). Annotations go BEFORE the
+ *  client's message, so its details JSON object stays the final token (README, Error text grammar). */
 export function intakeToolError(err, requirement) {
     if (err instanceof ConduytApiError) {
         if (err.status === 403)
-            return formatToolError(`${err.message}. This tool needs ${requirement}.`);
+            return formatToolError(`This tool needs ${requirement}. ${err.message}`);
         if (err.status === 503 && err.retryAfterSeconds !== null) {
-            return formatToolError(`busy; retry after ${err.retryAfterSeconds} s (${err.message})`);
+            return formatToolError(`busy; retry after ${err.retryAfterSeconds} s: ${err.message}`);
         }
     }
     throw err;
 }
 export function registerFormIntakeTools(server, client) {
+    server.tool("conduyt_get_form_intake_status", "Whether the account has any ACTIVE WordPress forms intake address, and how many: { data: { hasActive, activeCount } } (GET /api/v1/integrations/wordpress-forms/status). A boolean and a count only, never an intake, URL or token: use conduyt_list_form_intakes for the addresses (that needs the stronger form-intakes authority). The Connections page's WordPress forms row reads this. Read-only; requires " +
+        STATUS_REQUIREMENT +
+        "; a 403 is surfaced with that requirement.", {}, async () => {
+        try {
+            const result = await client.get("/api/v1/integrations/wordpress-forms/status");
+            return formatResult(result);
+        }
+        catch (err) {
+            return intakeToolError(err, STATUS_REQUIREMENT);
+        }
+    });
     server.tool("conduyt_list_form_intakes", "List the account's WordPress form intake addresses: every active intake (newest first), then the revoked history (the newest 200 revocations): name, defaultTag, source, assignee, status, receivedCount, lastReceivedAt and `url`: the full address of every ACTIVE intake (the credential, to paste into the form plugin); null for a revoked one. Requires " +
         LIST_AND_CREATE_REQUIREMENT +
         " (the URLs are credentials that create and edit contacts).", {}, async () => {

package/dist/tools/lifecycle.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { ConduytApiError, formatResult } from "../client.js";
+import { strictInput } from "./strict.js";
 /** (default columns r18, Codex r17 h1) every general-settings PATCH names the revision it loaded: read it, save, and on a 409 hand
  *  the conflict back with the current settings so the caller re-derives its change (tri-surface parity with the browser) */
 export async function patchGeneralSettings(client, body) {
@@ -98,6 +99,14 @@ export function registerLifecycleTools(server, client) {
                 ? "null = not chosen yet (legacy account) — 'pipeline': every inbound contact gets a deal card (intakeDeals required); 'status': the contact is the opportunity"
                 : undefined,
             lostPropagation,
+            // (card ownership per lane, 10-09) false = a booking uses the contact's existing open card in the intake pipeline. A stored value
+            // is shown as is; absent in a FULL snapshot (never saved; the runtime treats it as false) is false; absent in a REDUCED snapshot
+            // (a caller without settings.view) is null + note. The full view always carries `accountId` and the reduced one never does.
+            ...(typeof raw.bookingCreatesOwnCard === "boolean"
+                ? { bookingCreatesOwnCard: raw.bookingCreatesOwnCard }
+                : typeof raw.accountId === "string"
+                    ? { bookingCreatesOwnCard: false }
+                    : { bookingCreatesOwnCard: null, bookingCreatesOwnCardNote: "not visible to this role (needs settings.view)" }),
             masterStatuses: {
                 defaults: DEFAULT_MASTER_STATUSES,
                 customs,
@@ -128,6 +137,9 @@ export function registerLifecycleTools(server, client) {
     server.tool("conduyt_update_lost_propagation", "Turn LOST propagation on or off for this tenant (Lifecycle v3 P2). When on: a contact's masterStatus flips to 'lost' within a minute of its LAST open deal card closing lost (a per-minute resolver applies the rule on the committed state) (carrying that card's lostReason into masterStatusReason), a new open card on a lost/abandoned/disqualified contact reopens it, and a won contact never flips. Forward-only from the first enable (enabledAt is stamped server-side): existing history never flips by itself. A terminal masterStatus silences every drip, sequence and playbook for that contact, so read the nightly shadow report first (job run 'lost-propagation-shadow': contacts that would flip, their reasons, and the automations that would go quiet) before enabling.", {
         enabled: z.boolean().describe("true = flips happen live from now on; false = shadow report only"),
     }, async ({ enabled }) => patchGeneralSettings(client, { lostPropagation: { enabled } }));
+    strictInput(server.tool("conduyt_update_booking_creates_own_card", "Set settings.bookingCreatesOwnCard (card ownership per lane, PATCH /api/v1/settings). true: a booking creates a NEW card in the intake-deals pipeline and stage (conduyt_update_intake_deals), owned by the booking's host, instead of using the contact's existing open card there. false (the default): the contact's existing open card is used. Read the current value with conduyt_get_lifecycle_settings (bookingCreatesOwnCard). Requires settings:edit; a stale settings revision is handed back as a conflict with the current settings.", {
+        enabled: z.boolean().describe("true = each booking creates its own card owned by the host; false = reuse the contact's open intake card (default)"),
+    }, async ({ enabled }) => patchGeneralSettings(client, { bookingCreatesOwnCard: enabled })));
     server.tool("conduyt_update_disposition_status_map", "Set which lead status each call disposition sets when it is picked (by a rep after a call or by the AI auto-disposition): e.g. {\"not-interested\": \"lost\", \"sale-closed\": \"won\", \"interested\": \"working\"}. Keys are disposition values (built-ins like interested, not-interested, callback-requested, appointment-set, sale-closed, dnc-requested, voicemail, no-answer, wrong-number, or the account's custom outcomes); values are master statuses (open, won, lost, abandoned, disqualified, or the account's customs from conduyt_update_master_statuses). The map REPLACES the stored map (send the full map; {} clears every mapping); the rest of the account's disposition settings are untouched. An unknown disposition or status is a 422. A lead a deal has WON is never moved by an outcome; mapping to a terminal status (won/lost/abandoned/disqualified) closes the lead and stops its automations. Read the current map with conduyt_get_lifecycle_settings (dispositionStatusMap).", {
         statusMap: z
             .record(z.string().trim().min(1).max(40), z.string().trim().min(1).max(40))

package/dist/tools/messaging.d.ts

@@ -1,3 +1,17 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ConduytClient } from "../client.js";
+/** What the message check needs of an API key's member (a read-tier key may call it): the API names only the route, so a 403 is surfaced with all of it. */
+export declare const CHECK_MESSAGE_REQUIREMENT = "a key with the contacts, emails, sms or messages scope (a read-tier key too) whose member may view contacts (contacts.view) or email templates (email_templates.view)";
+/**
+ * The check's refusals, surfaced verbatim and never replayed (the client retries GETs only). 403 forbidden names the full requirement; 429
+ * rate_limited says when to retry (20 per minute per account). 400 invalid_body and 413 message_too_long / body_too_large pass through
+ * untouched. Annotations go BEFORE the client's message, so its details JSON object stays the final token (README, Error text grammar).
+ */
+export declare function checkMessageError(err: unknown): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError: true;
+};
 export declare function registerMessagingTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/messaging.js

@@ -1,6 +1,46 @@
 import { z } from "zod";
-import { formatResult } from "../client.js";
+import { ConduytApiError, formatResult, formatToolError } from "../client.js";
+import { strictInput } from "./strict.js";
+/** What the message check needs of an API key's member (a read-tier key may call it): the API names only the route, so a 403 is surfaced with all of it. */
+export const CHECK_MESSAGE_REQUIREMENT = "a key with the contacts, emails, sms or messages scope (a read-tier key too) whose member may view contacts (contacts.view) or email templates (email_templates.view)";
+/**
+ * The check's refusals, surfaced verbatim and never replayed (the client retries GETs only). 403 forbidden names the full requirement; 429
+ * rate_limited says when to retry (20 per minute per account). 400 invalid_body and 413 message_too_long / body_too_large pass through
+ * untouched. Annotations go BEFORE the client's message, so its details JSON object stays the final token (README, Error text grammar).
+ */
+export function checkMessageError(err) {
+    if (err instanceof ConduytApiError) {
+        if (err.status === 403)
+            return formatToolError(`This tool needs ${CHECK_MESSAGE_REQUIREMENT}. ${err.message}`);
+        if (err.status === 429) {
+            return formatToolError(`${err.retryAfterSeconds !== null ? `rate limited (20 checks per minute per account); retry after ${err.retryAfterSeconds} s` : "rate limited (20 checks per minute per account)"}: ${err.message}`);
+        }
+    }
+    throw err;
+}
 export function registerMessagingTools(server, client) {
+    strictInput(server.tool("conduyt_check_message", "Grade a DRAFT text or email before it is sent (POST /api/v1/messages/check): the same check the contact composers run as the rep types (the conduyt.com checker engine). Answers { data: { score 0-100, grade A-F, verdict (e.g. 'Good to send', 'Edit these words first', \"Don't send\"), vclass, hits[], subjectHits[] (email), checks[], sms (a text's chars / segments / unicode / perSeg; null for an email), context, notices[] (when the engine carries them; informational), engine { version, updatedAt } } }. Each hit: { start, end, word, level (r likely blocked, a risky, y caution, n heads up), label, cat, why, alts[] (safer wording; some entries are advice rather than a swap), restricted (prohibited in US business texting: no rewording makes it deliverable), rule }. start/end are Unicode CODE-POINT offsets into the submitted text (the body for hits, the subject for subjectHits), end exclusive; an emoji counts as one, so [...text].slice(start, end) in JavaScript or text[start:end] in Python is the word (not a UTF-16 index). The check EDUCATES and never blocks: nothing is stored and nothing is sent, it only suggests; merge tokens such as {{contact.firstName}} are never flagged. context: 'template' (default) grades it as a reusable message, 'first' is the first text to a contact, 'conversation' is a reply in an existing thread (the next engine release skips the opt-out and business-name checks for first / conversation; today every context scores the same). To pick first vs conversation for a real contact read hasOutboundSms on conduyt_get_contact. subject is email only (a subject on a text is refused 400 invalid_body). Limits: body 10,000 characters, subject 300, request 48 KB; 20 checks per minute per account. Refusals are surfaced verbatim and never retried: 400 invalid_body, 403 forbidden, 413 message_too_long / body_too_large, 429 rate_limited (with Retry-After). Requires " +
+        CHECK_MESSAGE_REQUIREMENT +
+        ".", {
+        channel: z.enum(["sms", "email"]).describe("sms = a text, email = an email"),
+        subject: z.string().max(300).optional().describe("Email only (300 characters at most); refused on a text"),
+        body: z.string().max(10000).describe("The draft text (10,000 characters at most)"),
+        context: z.enum(["template", "first", "conversation"]).optional().describe("Where the message sits: template (default), first (first text to a contact) or conversation (a reply in an existing thread)"),
+    }, async ({ channel, subject, body, context }) => {
+        try {
+            // the body as ONE literal: the contract gate reads the request fields from it
+            const result = await client.post("/api/v1/messages/check", {
+                channel,
+                ...(subject !== undefined ? { subject } : {}),
+                body,
+                ...(context !== undefined ? { context } : {}),
+            });
+            return formatResult(result);
+        }
+        catch (err) {
+            return checkMessageError(err);
+        }
+    }));
     server.tool("conduyt_sms_transports", "What a workflow Send SMS step can speak through TODAY (GET /api/v1/sms/transports): twilio {connected, numbers[] = the account number + every active rep's assigned line, each a valid send_sms config.fromNumber}, projectBlue {connected, lines[] = Project Blue iPhone lines held by active reps, each lineId a valid config.projectBlueLineId for smsMode project_blue}, whatsapp {connected, sender = the account's WhatsApp sender for smsMode whatsapp; templates come from conduyt_whatsapp_templates}, voiceDrop {connected = Twilio is connected, recordings {hasDefault, templates[] = names valid as config.voiceDropRecording for smsMode voice_drop}}, webhook {providers = active webhook providers for smsMode webhook}, fromk {status connected | setup, connected, lines[] = the FromK.ai workspace's send-ready lines, each phoneNumberId a valid config.fromkPhoneNumberId for smsMode fromk}. Use it before building or editing a send_sms step so you never configure a transport that is not connected. Requires automations:view.", {}, async () => {
         const result = await client.get("/api/v1/sms/transports");
         return formatResult(result);

package/dist/tools/tasks.js

@@ -49,7 +49,7 @@ export function registerTaskTools(server, client) {
         const result = await client.get(`/api/v1/tasks?${params}`);
         return formatResult(result);
     });
-    server.tool("conduyt_create_task", "Create a new task. Can be linked to a contact or deal and assigned to a team member.", {
+    server.tool("conduyt_create_task", "Create a new task. Can be linked to a contact or deal and assigned to a team member. This is the ORDINARY task route: ordinary tasks are unconstrained and may coexist with or race a Pipeline health quick-fix task. The database allows at most one non-done quick-fix task per deal (a second is refused 409 deal_has_next_action); to create the quick fix itself (checkOrigin + expectedDealUpdatedAt, guarded against a deal that changed) use conduyt_pipeline_health_fix_next_action. A 409 without a code means the contact was merged or deleted mid-request: retry against the surviving record. Errors reach you verbatim and are never retried.", {
         title: z.string().describe("Task title"),
         description: z.string().optional().describe("Task description"),
         dueDate: z.string().optional().describe("Due date (ISO 8601)"),
@@ -68,7 +68,7 @@ export function registerTaskTools(server, client) {
         const result = await client.get(`/api/v1/tasks/${encodeURIComponent(id)}`);
         return formatResult(result);
     });
-    server.tool("conduyt_update_task", "Update an existing task's fields. Only the fields you provide are changed; omit a field to leave it as-is. To mark a task done, prefer conduyt_complete_task. Requires tasks:edit.", {
+    server.tool("conduyt_update_task", "Update an existing task's fields. Only the fields you provide are changed; omit a field to leave it as-is. To mark a task done, prefer conduyt_complete_task. Requires tasks:edit. A 409 means nothing was written, surfaced verbatim and never retried: code deal_has_next_action (\"This deal already has a next action booked.\": re-opening or re-linking a quick-fix task would give the deal a second open one), or no code (the task changed while saving: read it again and retry).", {
         id: z.string().uuid().describe("Task UUID to update"),
         title: z.string().optional().describe("Updated task title"),
         description: z.string().optional().describe("Updated description (pass an empty string to clear it)"),

package/dist/tools/workflow-sandbox.js

@@ -8,7 +8,7 @@ function unwrap(response) {
 }
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export function registerWorkflowSandboxTools(server, client) {
-    server.tool("conduyt_workflow_validate", "Validate a workflow graph WITHOUT saving it. Returns errors and warnings so you can fix issues before creating or publishing. Always call this before conduyt_workflow_promote.", {
+    server.tool("conduyt_workflow_validate", "Validate a workflow graph WITHOUT saving it. Returns errors and warnings so you can fix issues before creating or publishing. Always call this before conduyt_workflow_promote. An action config key the action does not read, or an unregistered action type, comes back as an error with code `unknown_action_config_key` / `unknown_action_type` and a \"Did you mean\" suggestion.", {
         triggerEvent: z.string().describe("Trigger event (e.g. 'contact.created', 'deal.stage_changed', 'tag.added', 'scheduled')"),
         graph: z.object({
             nodes: z.array(z.object({
@@ -40,7 +40,7 @@ export function registerWorkflowSandboxTools(server, client) {
         const result = await client.post(`/api/v1/automations/${automationId}/dry-run`, body);
         return formatResult(result);
     });
-    server.tool("conduyt_workflow_promote", "Safely publish a workflow. First validates the current graph — if there are errors, returns them and refuses to publish. If validation passes, publishes the draft to live. This is the recommended way to go live — it prevents broken workflows from reaching contacts.", {
+    server.tool("conduyt_workflow_promote", "Safely publish a workflow. First validates the current graph — if there are errors, returns them and refuses to publish. If validation passes, publishes the draft to live. This is the recommended way to go live — it prevents broken workflows from reaching contacts. A validation error (including `unknown_action_config_key` / `unknown_action_type`, with a suggestion) is returned and nothing is published; a publish preflight refusal (422) is surfaced verbatim.", {
         automationId: z.string().describe("Automation UUID to promote to live"),
         allowWarnings: z.boolean().optional().describe("Publish even if there are warnings (default true). Set false to block on warnings too."),
     }, async ({ automationId, allowWarnings }) => {
@@ -77,9 +77,12 @@ export function registerWorkflowSandboxTools(server, client) {
                 message: "Workflow has warnings and allowWarnings is false. Fix warnings or set allowWarnings to true.",
             });
         }
-        // (Conduyt Sentry r59 parity) the publish carries the revision of the draft that was just validated
-        const current = (await client.get(`/api/v1/automations/${automationId}`));
-        const published = await client.post(`/api/v1/automations/${automationId}/publish`, { expectedConfigRevision: typeof current?.configRevision === "number" ? current.configRevision : undefined });
+        // (Conduyt Sentry r59 parity) the publish carries the configRevision of the SAME snapshot that was just validated (the GET
+        // above, already unwrapped from { data }): no second read, so no save can slip between the review and the publish
+        if (typeof automation.configRevision !== "number") {
+            return formatResult({ promoted: false, error: "The automation read carried no configRevision, so the publish cannot be bound to the draft that was validated. Nothing was published." });
+        }
+        const published = await client.post(`/api/v1/automations/${automationId}/publish`, { expectedConfigRevision: automation.configRevision });
         return formatResult({
             promoted: true,
             warnings: hasWarnings ? validation.warnings : [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.79.0",
+  "version": "4.81.0",
   "mcpName": "com.conduyt/mcp",
   "description": "MCP server for Conduyt CRM — expose CRM operations as AI-accessible tools",
   "type": "module",

package/scripts/coverage-matrix.json

@@ -1,9 +1,9 @@
 {
-  "generatedAt": "2026-10-09T04:00:29.593Z",
-  "toolCount": 334,
-  "totalEndpoints": 1066,
+  "generatedAt": "2026-10-09T16:41:23.942Z",
+  "toolCount": 339,
+  "totalEndpoints": 1068,
   "counts": {
-    "covered": 299,
+    "covered": 301,
     "excluded": 319,
     "planned": 448,
     "uncategorized": 0
@@ -637,7 +637,6 @@
       "status": "covered",
       "tools": [
         "conduyt_get_automation",
-        "conduyt_update_automation",
         "conduyt_publish_automation",
         "conduyt_workflow_promote"
       ]
@@ -2165,6 +2164,7 @@
     "PATCH /api/v1/deals/:id": {
       "status": "covered",
       "tools": [
+        "conduyt_pipeline_health_fix_deal",
         "conduyt_update_deal"
       ]
     },
@@ -3094,6 +3094,12 @@
         "conduyt_revoke_form_intake"
       ]
     },
+    "GET /api/v1/integrations/wordpress-forms/status": {
+      "status": "covered",
+      "tools": [
+        "conduyt_get_form_intake_status"
+      ]
+    },
     "GET /api/v1/integrations/zapier/sample/:event": {
       "status": "planned",
       "reason": "integration management"
@@ -3202,6 +3208,12 @@
       "status": "planned",
       "reason": "message surfaces beyond send tools"
     },
+    "POST /api/v1/messages/check": {
+      "status": "covered",
+      "tools": [
+        "conduyt_check_message"
+      ]
+    },
     "GET /api/v1/messages/sms/:id": {
       "status": "planned",
       "reason": "message surfaces beyond send tools"
@@ -4495,6 +4507,7 @@
     "POST /api/v1/tasks": {
       "status": "covered",
       "tools": [
+        "conduyt_pipeline_health_fix_next_action",
         "conduyt_create_task"
       ]
     },