conduyt-mcp 4.74.0 → 4.76.0

package/README.md

@@ -23,7 +23,12 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 ### Deals
 | Tool | Description |
 |------|-------------|
-| `conduyt_list_deals` | List deals by pipeline, stage, or assignee |
+| `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_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` |
+| `conduyt_get_pipeline_rot_days` / `conduyt_set_pipeline_rot_days` | Read / set the stale-in-stage threshold per pipeline (`pipelineRotDays`, 1-90 days); only the pipelines sent change; revision-aware, retried once on a 409 |
 | `conduyt_get_deal` | Get deal details with history, including custom-field values |
 | `conduyt_create_deal` | Create a deal with full attributes — currency (e.g. GBP), probability, priority, expected close date, contact/company, and structured custom-field values |
 | `conduyt_update_deal` | Move stage, change value/currency, set probability or close date, reassign, mark won/lost, or write custom-field values; optional `expectedUpdatedAt` pins the `updatedAt` you read, and a stale pin returns 409 `deal_changed` with the current `updatedAt` and writes nothing |
@@ -38,13 +43,17 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 ### Pipelines
 | Tool | Description |
 |------|-------------|
-| `conduyt_list_pipelines` | List pipelines with stages |
-| `conduyt_create_pipeline` | Create a pipeline, optionally with its full set of stages (no stage-count cap; up to 50) |
-| `conduyt_update_pipeline` | Rename a pipeline, change its description, or set it as default |
+| `conduyt_list_pipelines` | List active pipelines with stages (each carries `color`, `automationOnly`, `sortOrder`) |
+| `conduyt_list_archived_pipelines` | List archived pipelines (`GET /pipelines?archived=true`, owner / admin key): `id`, `name`, `archivedName`, `color`, `archivedAt`, `openDeals`, `stageCount` |
+| `conduyt_create_pipeline` | Create a pipeline, optionally with its full set of stages (no stage-count cap; up to 50) and a palette `color` |
+| `conduyt_update_pipeline` | Rename a pipeline, change its description, set it as default, set `automationOnly` (only automations, API keys and owners / admins move or edit its cards), `color` (one of the 10 palette colours) or `sortOrder` (owner / admin key) |
+| `conduyt_archive_pipeline` | Archive a pipeline and move its open deals to another pipeline in one transaction (`moveOpenDealsTo`, optional `expectedSettingsRevision`); refusals carry `stale_settings_revision`, `target_not_open`, `dpp_post_close`, `archive_too_large`, `target_archived`, `intake_target`, `pipeline_archived`; an already-archived pipeline answers `alreadyArchived` |
+| `conduyt_restore_pipeline` | Restore an archived pipeline (appended last, never the default; 409 `name_taken` when an active pipeline has its name) |
+| `conduyt_reorder_pipelines` / `conduyt_reorder_stages` | Set the board-menu order of the pipelines / a pipeline's column order in one transaction with `expectedRevision` (409 `order_changed` carries the current revision) |
 | `conduyt_delete_pipeline` | Delete a pipeline (move/remove its deals first) |
 | `conduyt_create_stage` | Append a stage to a pipeline (e.g. 'On Hold', 'Declined/Dead') |
 | `conduyt_update_stage` | Rename, recolor, reorder, or change won/lost flags on a stage |
-| `conduyt_delete_stage` | Delete an empty stage from a pipeline |
+| `conduyt_delete_stage` | Delete a stage from a pipeline; `moveTo` moves its live deals to another stage first, `expectedSettingsRevision` refuses the delete when settings changed (409 `stale_settings_revision`; the answer then carries the new `settingsRevision`) |
 
 ### Activities
 | Tool | Description |
@@ -159,6 +168,30 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | `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) |
 
+### Status metadata
+| Tool | Description |
+|------|-------------|
+| `conduyt_list_status_metadata` / `conduyt_get_status_metadata` | Read the status taxonomy rows (one per stage and code); `updatedAt` is the version for `expectedUpdatedAt` |
+| `conduyt_create_status_metadata` | Create a row (`stageId`, `code`, `bucket` slugs, `lifecycleStage`, drip fields, `isTerminal`, `notes`) |
+| `conduyt_update_status_metadata` | Update a row; `expectedUpdatedAt` refuses a row changed or moved since (409 `metadata_changed` with the current row); 404 `status_metadata_not_found` |
+| `conduyt_delete_status_metadata` | Delete a row (`expectedUpdatedAt` as above) |
+| `conduyt_import_status_metadata` | Set-based import (max 1000; `merge` or `replace`); read `errors[]` even on a 200; 409 `pipeline_archived` when an item names a stage of an archived pipeline |
+
+### Mailchimp (API key scope `integrations`)
+| Tool | Description |
+|------|-------------|
+| `conduyt_get_mailchimp_settings` | The Mailchimp connection: audience, source, settings and sync status (`connected: false` when none) |
+| `conduyt_update_mailchimp_settings` | `PUT` the audience (`listId`), source (smart list or tag), `statusIfNew`, `unsubscribeSetsOptOut`; only the fields sent change |
+| `conduyt_list_mailchimp_audiences` | The connected account's audiences (`id`, `name`, `memberCount`) |
+| `conduyt_mailchimp_push_now` | Run one sync pass now (`ran` is false while another pass holds the connection) |
+| `conduyt_mailchimp_retry_unsubscribes` | Retry undelivered unsubscribes (one per account per 10 minutes: 429 `retry_cooldown`) |
+| `conduyt_mailchimp_reconcile_statuses` | Full reconciliation of a blocked unsubscribe check (`restart: true` replaces a completed run; else 409 `reconciliation_completed`); owner / admin key |
+| `conduyt_mailchimp_confirm_reconciliation` | Confirm the reconciliation report and resume the check; owner / admin key |
+
+Timeouts: the Mailchimp write/action tools and `conduyt_import_status_metadata` use a 60 s per-call timeout and `conduyt_archive_pipeline` 75 s (the client default is 30 s), above the server budgets; if a call still reports a timeout the server may have applied it, so re-read (`conduyt_get_mailchimp_settings`, `conduyt_list_pipelines` / `conduyt_list_archived_pipelines`, `conduyt_list_status_metadata`) before repeating it. The destructive tools (both deletes, archive, restore, reorders, status-metadata import and writes, Mailchimp settings and reconcile) take a strict input: a wire spelling such as `expected_updated_at` or a typo is InvalidParams and nothing is sent; an import item with an unknown key is refused as a whole, and `mode: "replace"` with no items (which would delete every row) is refused before any request. Tools without arguments (push, retry, confirm-reconciliation, the reads) reject any argument too. A body that stalls after the headers until the deadline is reported as the same "may have applied it" timeout, never retried for a mutation.
+
+The Mailchimp OAuth connect and callback are browser-only: connect Mailchimp in the app (Settings > Integrations), then configure it here.
+
 ### Notifications
 | Tool | Description |
 |------|-------------|

package/dist/client.js

@@ -29,6 +29,9 @@ const DEFAULT_RETRY_BASE_MS = 500;
 const MAX_GET_RETRIES = 2;
 const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
 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.";
 export class ConduytClient {
     baseUrl;
     apiKey;
@@ -76,11 +79,11 @@ export class ConduytClient {
             });
         }
         catch (err) {
-            if (err?.name === "TimeoutError" || err?.name === "AbortError") {
+            if (isAbort(err)) {
                 throw new ConduytApiError({
-                    message: `Conduyt API timeout: no response within ${timeoutMs}ms for ${method} ${path}`,
+                    message: `Conduyt API timeout: no response within ${timeoutMs}ms for ${method} ${path}` + (method === "GET" ? "" : AMBIGUOUS),
                     code: "timeout",
-                    retryable: true,
+                    retryable: method === "GET",
                     cause: err,
                 });
             }
@@ -126,6 +129,16 @@ export class ConduytClient {
             catch (err) {
                 if (err instanceof ConduytApiError)
                     throw err;
+                // headers arrived but the body stalled until the deadline: for a mutation the write may well have been applied
+                if (isAbort(err)) {
+                    throw new ConduytApiError({
+                        message: `Conduyt API timeout: the response body for ${method} ${path} did not finish within ${timeoutMs}ms` + (method === "GET" ? "" : AMBIGUOUS),
+                        status: res.status,
+                        code: "timeout",
+                        retryable: method === "GET",
+                        cause: err,
+                    });
+                }
                 throw new ConduytApiError({
                     message: `Conduyt API network error reading response for ${method} ${path}: ${err?.message ?? String(err)}`,
                     code: "network",

package/dist/index.js

@@ -22,6 +22,9 @@ import { registerFormTools } from "./tools/forms.js";
 import { registerInvoiceTools } from "./tools/invoices.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
 import { registerFormIntakeTools } from "./tools/form-intakes.js";
+import { registerBoardSettingsTools } from "./tools/board-settings.js";
+import { registerMailchimpTools } from "./tools/mailchimp.js";
+import { registerStatusMetadataTools } from "./tools/status-metadata.js";
 import { registerNotificationTools } from "./tools/notifications.js";
 import { registerCustomFieldTools } from "./tools/custom-fields.js";
 import { registerSmartListTools } from "./tools/smart-lists.js";
@@ -95,6 +98,9 @@ registerFormTools(server, client);
 registerInvoiceTools(server, client);
 registerWebhookTools(server, client);
 registerFormIntakeTools(server, client);
+registerBoardSettingsTools(server, client);
+registerMailchimpTools(server, client);
+registerStatusMetadataTools(server, client);
 registerNotificationTools(server, client);
 registerCustomFieldTools(server, client);
 registerSmartListTools(server, client);

package/dist/tools/automations.js

@@ -26,7 +26,7 @@ export function registerAutomationTools(server, client) {
         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."),
+        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)."),
         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')"),
@@ -48,7 +48,7 @@ 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'})"),
+        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)."),
         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"),

package/dist/tools/board-settings.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ConduytClient } from "../client.js";
+/**
+ * Deal board settings (app 10-08, BDA board): per-stage rules (settings.pipelineStageRules[pipelineId][stageId]) and the
+ * kanban card fields (settings.dealCardFields). The validators mirror the API's settingsPatchSchema entries, which are
+ * the source of truth: the built-in names below are the app's lists, `custom:<fieldKey>` names one of the account's DEAL
+ * custom fields (the API checks it exists at save), and the stage rule object is strict (no other keys).
+ */
+export declare const DEAL_STAGE_REQUIRED_FIELDS: readonly ["value", "expectedCloseDate", "contactId", "assignedTo", "lostReason"];
+export declare const DEAL_CARD_FIELDS: readonly ["value", "contact", "phones", "company", "owner", "priority", "expectedCloseDate", "daysInStage", "nextAction", "tags", "stageHealth", "source"];
+export declare const MAX_DEAL_CARD_FIELDS = 8;
+export declare const MAX_STAGE_REQUIRED_FIELDS = 25;
+export declare const MAX_STAGE_REQUIRED_DOCUMENTS = 20;
+export declare const MIN_PIPELINE_ROT_DAYS = 1;
+export declare const MAX_PIPELINE_ROT_DAYS = 90;
+export declare function registerBoardSettingsTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/board-settings.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { formatResult } from "../client.js";
+import { strictInput } from "./strict.js";
+import { patchGeneralSettingsMerged } from "./lifecycle.js";
+/**
+ * Deal board settings (app 10-08, BDA board): per-stage rules (settings.pipelineStageRules[pipelineId][stageId]) and the
+ * kanban card fields (settings.dealCardFields). The validators mirror the API's settingsPatchSchema entries, which are
+ * the source of truth: the built-in names below are the app's lists, `custom:<fieldKey>` names one of the account's DEAL
+ * custom fields (the API checks it exists at save), and the stage rule object is strict (no other keys).
+ */
+export const DEAL_STAGE_REQUIRED_FIELDS = ["value", "expectedCloseDate", "contactId", "assignedTo", "lostReason"];
+export const DEAL_CARD_FIELDS = ["value", "contact", "phones", "company", "owner", "priority", "expectedCloseDate", "daysInStage", "nextAction", "tags", "stageHealth", "source"];
+export const MAX_DEAL_CARD_FIELDS = 8;
+export const MAX_STAGE_REQUIRED_FIELDS = 25;
+export const MAX_STAGE_REQUIRED_DOCUMENTS = 20;
+const CUSTOM_FIELD_RE = /^custom:[a-zA-Z_][a-zA-Z0-9_]*$/;
+const RULE_KEYS = ["requiredFields", "requiredDocuments", "lostReasonLabel", "lostReasonOptions", "lostReasonAllowOther"];
+export const MIN_PIPELINE_ROT_DAYS = 1;
+export const MAX_PIPELINE_ROT_DAYS = 90;
+const requiredField = z.union([
+    z.enum(DEAL_STAGE_REQUIRED_FIELDS),
+    z.string().regex(CUSTOM_FIELD_RE, "custom required fields are custom:<deal custom field key>"),
+]);
+const cardField = z.union([
+    z.enum(DEAL_CARD_FIELDS),
+    z.string().regex(CUSTOM_FIELD_RE, "custom card fields are custom:<deal custom field key>"),
+]);
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+export function registerBoardSettingsTools(server, client) {
+    strictInput(server.tool("conduyt_get_stage_rules", "Read the per-stage rules (settings.pipelineStageRules) as { pipelineId: { stageId: { requiredFields, requiredDocuments, lostReasonLabel, lostReasonOptions, lostReasonAllowOther } } }, optionally for one pipeline or one stage. A deal may enter a stage only when its requiredFields are filled (built-ins value, expectedCloseDate, contactId, assignedTo, lostReason, or custom:<fieldKey> for a deal custom field) and it has at least requiredDocuments documents attached. Set one stage with conduyt_set_stage_rules. Pipelines your key cannot see are left out.", {
+        pipelineId: z.string().uuid().optional().describe("Only this pipeline's stage rules"),
+        stageId: z.string().uuid().optional().describe("Only this stage's rule (needs pipelineId)"),
+    }, async ({ pipelineId, stageId }) => {
+        if (stageId && !pipelineId)
+            throw new Error("stageId needs pipelineId.");
+        const result = (await client.get("/api/v1/settings"));
+        const all = isObj(result?.data?.pipelineStageRules) ? result.data.pipelineStageRules : {};
+        let out = all;
+        if (pipelineId) {
+            const stages = isObj(all[pipelineId]) ? all[pipelineId] : {};
+            out = { [pipelineId]: stageId ? (stages[stageId] !== undefined ? { [stageId]: stages[stageId] } : {}) : stages };
+        }
+        return formatResult({ data: { pipelineStageRules: out } });
+    }));
+    strictInput(server.tool("conduyt_set_stage_rules", "Set the rule of ONE stage (settings.pipelineStageRules[pipelineId][stageId]; admin key, settings:edit). Only the fields you pass change: they are merged into that stage's current rule, and every other stage and pipeline is left exactly as stored. requiredFields REPLACES the stage's list (max 25 entries; built-ins value, expectedCloseDate, contactId, assignedTo, lostReason, or custom:<fieldKey> for one of the account's DEAL custom fields; [] clears it); requiredDocuments is the number of documents that must be attached before a deal may enter the stage (integer 0-20); lostReasonLabel (1-60 chars) and lostReasonOptions (max 50, trimmed and de-duplicated by the API) configure the stage's lost-reason prompt; lostReasonAllowOther (boolean) lets the rep also pick \"Other\" and type the reason (stored as the reason text; only takes effect while the stage has lost-reason options). Read-merge-write with the settings revision; if another save lands first it is re-read and retried once, then the conflict is returned with the current settings. An unknown custom field key, pipeline or stage is refused by the API.", {
+        pipelineId: z.string().uuid().describe("Pipeline UUID"),
+        stageId: z.string().uuid().describe("Stage UUID within that pipeline"),
+        requiredFields: z.array(requiredField).max(MAX_STAGE_REQUIRED_FIELDS).optional().describe("Fields a deal must have filled to enter the stage: value, expectedCloseDate, contactId, assignedTo, lostReason, or custom:<deal custom field key>. Replaces the list."),
+        requiredDocuments: z.number().int().min(0).max(MAX_STAGE_REQUIRED_DOCUMENTS).optional().describe("Documents that must be attached to the deal before it enters the stage (integer 0-20)"),
+        lostReasonLabel: z.string().trim().min(1).max(60).optional().describe("Label of the stage's lost-reason prompt, e.g. 'Disqualification Reason'"),
+        lostReasonOptions: z.array(z.string()).max(50).optional().describe("Dropdown options of the lost-reason prompt (replaces the list)"),
+        lostReasonAllowOther: z.boolean().optional().describe("The rep may pick 'Other' and type the reason (stored as the reason text). Needs lost-reason options to take effect."),
+    }, async ({ pipelineId, stageId, ...given }) => {
+        const change = Object.fromEntries(Object.entries(given).filter(([, v]) => v !== undefined));
+        if (Object.keys(change).length === 0) {
+            throw new Error("Nothing to set. Pass at least one of requiredFields, requiredDocuments, lostReasonLabel, lostReasonOptions, lostReasonAllowOther.");
+        }
+        return patchGeneralSettingsMerged(client, (settings) => {
+            const rules = isObj(settings.pipelineStageRules) ? settings.pipelineStageRules : {};
+            const stages = isObj(rules[pipelineId]) ? rules[pipelineId] : {};
+            const current = isObj(stages[stageId]) ? stages[stageId] : {};
+            const kept = Object.fromEntries(RULE_KEYS.filter((k) => current[k] !== undefined).map((k) => [k, current[k]]));
+            // the API merges per pipeline and replaces that pipeline's stage map: send the whole map with this stage changed
+            return { pipelineStageRules: { [pipelineId]: { ...stages, [stageId]: { ...kept, ...change } } } };
+        });
+    }));
+    server.tool("conduyt_get_deal_card_fields", "Read the fields shown on each kanban deal card, in order (settings.dealCardFields; max 8): built-in names (value, contact, phones, company, owner, priority, expectedCloseDate, daysInStage, nextAction, tags, stageHealth, source) and custom:<fieldKey> entries for the account's deal custom fields. Change with conduyt_set_deal_card_fields.", {}, async () => {
+        const result = (await client.get("/api/v1/settings"));
+        return formatResult({ data: { dealCardFields: result?.data?.dealCardFields ?? null } });
+    });
+    strictInput(server.tool("conduyt_set_deal_card_fields", "Set the fields shown on each kanban deal card, in order (settings.dealCardFields; admin key, settings:edit). REPLACES the list: 1 to 8 entries, each a built-in (value, contact, phones, company, owner, priority, expectedCloseDate, daysInStage, nextAction, tags, stageHealth, source) or custom:<fieldKey> for one of the account's DEAL custom fields (the API refuses an unknown key). Read the current list with conduyt_get_deal_card_fields. Saved with the settings revision; a stale revision is re-read and retried once.", {
+        fields: z.array(cardField).min(1).max(MAX_DEAL_CARD_FIELDS).describe("The complete ordered list, 1-8 entries"),
+    }, async ({ fields }) => patchGeneralSettingsMerged(client, () => ({ dealCardFields: fields }))));
+    strictInput(server.tool("conduyt_get_settings_revision", "Read the account settings revision (GET /api/v1/settings): { data: { settingsRevision, pipelineStageRules, pipelineRotDays } }. settingsRevision is the value to pass as expectedSettingsRevision to conduyt_archive_pipeline and conduyt_delete_stage so they are refused (409 stale_settings_revision) when settings changed after you read them; read it right before the mutation. The stage rules and stale-in-stage days it already reads are returned with it (null when none are stored).", {}, async () => {
+        const result = (await client.get("/api/v1/settings"));
+        const d = result?.data ?? {};
+        return formatResult({ data: { settingsRevision: typeof d.settingsRevision === "string" ? d.settingsRevision : null, pipelineStageRules: d.pipelineStageRules ?? null, pipelineRotDays: d.pipelineRotDays ?? null } });
+    }));
+    server.tool("conduyt_get_pipeline_rot_days", "Read the stale-in-stage threshold per pipeline (settings.pipelineRotDays) as { pipelineId: days }, optionally for one pipeline: the days without activity before a deal in that pipeline reads \"Stale in stage\" on the board health strip and rots on its card. A pipeline with no entry has no custom threshold set. Change one with conduyt_set_pipeline_rot_days.", {
+        pipelineId: z.string().uuid().optional().describe("Only this pipeline's threshold"),
+    }, async ({ pipelineId }) => {
+        const result = (await client.get("/api/v1/settings"));
+        const all = isObj(result?.data?.pipelineRotDays) ? result.data.pipelineRotDays : {};
+        const out = pipelineId ? (all[pipelineId] !== undefined ? { [pipelineId]: all[pipelineId] } : {}) : all;
+        return formatResult({ data: { pipelineRotDays: out } });
+    });
+    strictInput(server.tool("conduyt_set_pipeline_rot_days", "Set the stale-in-stage threshold of ONE or more pipelines (settings.pipelineRotDays; admin key, settings:edit): days without activity (integer 1-90) before a deal in the pipeline reads \"Stale in stage\". Only the pipelines you send change; every other pipeline keeps its value. The pipeline must be an ACTIVE pipeline of the account (422 for an unknown or archived one). Saved with the settings revision; a stale revision is re-read and retried once, then the conflict is returned with the current settings.", {
+        days: z.record(z.string().uuid(), z.number().int().min(MIN_PIPELINE_ROT_DAYS).max(MAX_PIPELINE_ROT_DAYS)).refine((d) => Object.keys(d).length > 0, "Pass at least one pipeline").describe("Pipeline UUID to days (1-90), e.g. { \"<pipelineId>\": 14 }"),
+    }, async ({ days }) => patchGeneralSettingsMerged(client, () => ({ pipelineRotDays: days }))));
+}

package/dist/tools/deals.d.ts

@@ -1,3 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ConduytClient } from "../client.js";
+/** The six Pipeline health checks (GET /deals health_check, GET /deals/inspection check). */
+export declare const PIPELINE_HEALTH_CHECKS: readonly ["high_value_idle", "stale", "unassigned", "needs_action", "missing_close_date", "missing_contact"];
 export declare function registerDealTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/deals.js

@@ -1,7 +1,12 @@
 import { z } from "zod";
 import { formatResult } from "../client.js";
+import { strictInput } from "./strict.js";
+/** The six Pipeline health checks (GET /deals health_check, GET /deals/inspection check). */
+export const PIPELINE_HEALTH_CHECKS = ["high_value_idle", "stale", "unassigned", "needs_action", "missing_close_date", "missing_contact"];
+const healthCheckSchema = z.enum(PIPELINE_HEALTH_CHECKS);
+const HEALTH_ERRORS = "A 400 carries a machine-readable code in the error text: health_cursor_invalid (forged cursor, or cursor with offset), health_cursor_context (cursor from another list or the view/thresholds changed), health_cursor_blank, health_cursor_needs_check (cursor without a check), health_filter_conflict (a filter given twice with different values).";
 export function registerDealTools(server, client) {
-    server.tool("conduyt_list_deals", "List deals with filtering by pipeline, stage, assignee, or status. Returns deal title, value, stage, contact, and dates. Filter by pipeline/stage NAME (the same names you import with) or by UUID — both camelCase (pipelineName) and snake_case (pipeline_name) argument names are accepted. An unknown name returns a clear error, never the whole account.", {
+    strictInput(server.tool("conduyt_list_deals", "List deals with filtering by pipeline, stage, assignee, or status. Returns deal title, value, stage, contact, and dates. Filter by pipeline/stage NAME (the same names you import with) or by UUID — both camelCase (pipelineName) and snake_case (pipeline_name) argument names are accepted. An unknown name returns a clear error, never the whole account. Each deal row carries hasNextStep (boolean: an open task or a booked appointment from a day ago on; the Needs next action rule's own answer) and nextAppointmentAt (ISO string or null; null unless your key can view the calendar, even when hasNextStep is true). PIPELINE HEALTH: pass health_summary=true to get the Pipeline health strip for the same filtered set instead of the deal list: { totalOpenDeals, atRiskValue, checks[] (key, label, severity, color, rule, count, value; the six checks high_value_idle, stale, unassigned, needs_action, missing_close_date, missing_contact, ordered by money at risk), deals }. Add health_check to also get that check's first page of deals (highest value first) as deals: { check, offset, items, hasMore, nextCursor, total }; deals is null without a check. Page with health_cursor (the previous nextCursor, passed back UNCHANGED: an opaque signed token) or health_offset, and health_rows_only=true to get just the page without the summary: the answer is {data:{deals:{check, offset, items, hasMore, nextCursor}}} (the page sits under data.deals). " + HEALTH_ERRORS, {
         pipeline: z.string().optional().describe("Filter by pipeline UUID (canonical). Aliases: pipelineId, pipeline_id."),
         pipelineId: z.string().optional().describe("Filter by pipeline UUID (alias of pipeline)."),
         pipeline_id: z.string().optional().describe("snake_case alias of pipelineId."),
@@ -17,6 +22,12 @@ export function registerDealTools(server, client) {
         search: z.string().optional().describe("Search deal titles"),
         page: z.number().optional().describe("Page number (default 1)"),
         per_page: z.number().optional().describe("Results per page (default 25, max 100)"),
+        health_summary: z.boolean().optional().describe("true: answer the Pipeline health shape (totalOpenDeals, atRiskValue, checks[], deals) for the filtered set instead of the deal list."),
+        health_check: healthCheckSchema.optional().describe("With health_summary: one check whose deals are added to `deals`, highest value first."),
+        health_limit: z.number().int().min(1).max(100).optional().describe("With health_summary and health_check: deals per page, 1-100 (default 5)."),
+        health_offset: z.number().int().min(0).optional().describe("With health_summary and health_check: deals to skip (default 0). Prefer health_cursor; never combine the two."),
+        health_cursor: z.string().optional().describe("With health_summary and health_check: continue after this cursor, the nextCursor of the previous page, passed back UNCHANGED (opaque signed token bound to the list; a blank, forged or foreign one is a 400 with its code)."),
+        health_rows_only: z.boolean().optional().describe("With health_summary and health_check: true answers only the requested page of that check's deals, without the summary (for the next page of a list); the answer is {data:{deals:{check, offset, items, hasMore, nextCursor}}}."),
     }, async (a) => {
         const params = new URLSearchParams();
         // Accept every reasonable casing of each filter (canonical bare name +
@@ -62,10 +73,46 @@ export function registerDealTools(server, client) {
             params.set("page", String(page));
         if (per_page)
             params.set("per_page", String(per_page));
+        // Pipeline health strip: sent only when given, the cursor byte for byte (it is signed; never trimmed or re-encoded by hand)
+        if (a.health_summary !== undefined)
+            params.set("health_summary", String(a.health_summary));
+        if (a.health_check !== undefined)
+            params.set("health_check", a.health_check);
+        if (a.health_limit !== undefined)
+            params.set("health_limit", String(a.health_limit));
+        if (a.health_offset !== undefined)
+            params.set("health_offset", String(a.health_offset));
+        if (a.health_cursor !== undefined)
+            params.set("health_cursor", a.health_cursor);
+        if (a.health_rows_only !== undefined)
+            params.set("health_rows_only", String(a.health_rows_only));
         const result = await client.get(`/api/v1/deals?${params}`);
         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).", {
+    }));
+    strictInput(server.tool("conduyt_pipeline_health", "Pipeline health for one pipeline (or every visible active pipeline) over its OPEN deals (GET /api/v1/deals/inspection): { totalOpenDeals, atRiskValue (total value of the High-value idle deals), checks[] (key, label, severity, color, rule, count, value; the six checks high_value_idle, stale, unassigned, needs_action, missing_close_date, missing_contact, ordered by money at risk), deals, summary (count per check), labels (label per check) }. With check, deals is that check's page { check, offset, items, hasMore, nextCursor, total } (highest value first, each item with its issues); without it deals is null. Page with cursor (the previous nextCursor, passed back UNCHANGED) or offset; never both. For the board's other filters (stage, assignee, saved view) use conduyt_list_deals with health_summary=true. " + HEALTH_ERRORS, {
+        pipeline: z.string().optional().describe("Pipeline UUID; omit for every visible active pipeline."),
+        check: healthCheckSchema.optional().describe("Adds `deals` for that check."),
+        limit: z.number().int().min(1).max(100).optional().describe("With check: deals per page, 1-100 (default 5)."),
+        offset: z.number().int().min(0).optional().describe("With check: deals to skip (default 0)."),
+        cursor: z.string().optional().describe("With check: continue after this cursor, the nextCursor of the previous page, passed back UNCHANGED. Not combined with offset."),
+    }, async ({ pipeline, check, limit, offset, cursor }) => {
+        const params = new URLSearchParams();
+        if (pipeline !== undefined)
+            params.set("pipeline", pipeline);
+        if (check !== undefined)
+            params.set("check", check);
+        if (limit !== undefined)
+            params.set("limit", String(limit));
+        if (offset !== undefined)
+            params.set("offset", String(offset));
+        if (cursor !== undefined)
+            params.set("cursor", cursor);
+        const qs = params.toString();
+        // literal paths on purpose: the coverage scanner reads the first string after client.get(, and a template with a nested template hid this endpoint from it
+        const result = qs ? await client.get("/api/v1/deals/inspection?" + qs) : await client.get("/api/v1/deals/inspection");
+        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 }) => {
         const result = await client.get(`/api/v1/deals/${id}`);

package/dist/tools/lifecycle.d.ts

@@ -8,4 +8,16 @@ export declare function patchGeneralSettings(client: ConduytClient, body: Record
         text: string;
     }>;
 }>;
+/**
+ * Read-merge-write for a settings change that depends on what is stored (a per-stage rule inside settings.pipelineStageRules):
+ * `build` derives the PATCH body from the settings just read, and the save carries that read's settingsRevision. A stale
+ * revision (409: another save landed first) re-reads and re-derives ONCE; a second 409 hands back the conflict with the
+ * current settings, like patchGeneralSettings. Anything other than a 409 is thrown. `build` may throw a plain Error to refuse.
+ */
+export declare function patchGeneralSettingsMerged(client: ConduytClient, build: (settings: Record<string, unknown>) => Record<string, unknown>): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
 export declare function registerLifecycleTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/lifecycle.js

@@ -19,6 +19,34 @@ export async function patchGeneralSettings(client, body) {
         throw err;
     }
 }
+/**
+ * Read-merge-write for a settings change that depends on what is stored (a per-stage rule inside settings.pipelineStageRules):
+ * `build` derives the PATCH body from the settings just read, and the save carries that read's settingsRevision. A stale
+ * revision (409: another save landed first) re-reads and re-derives ONCE; a second 409 hands back the conflict with the
+ * current settings, like patchGeneralSettings. Anything other than a 409 is thrown. `build` may throw a plain Error to refuse.
+ */
+export async function patchGeneralSettingsMerged(client, build) {
+    let lastRevision = null;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const read = (await client.get("/api/v1/settings"));
+        const settings = read?.data ?? {};
+        const revision = typeof settings.settingsRevision === "string" ? settings.settingsRevision : null;
+        lastRevision = revision;
+        const body = build(settings);
+        try {
+            return formatResult(await client.patch("/api/v1/settings", { ...body, ...(revision ? { expectedSettingsRevision: revision } : {}) }));
+        }
+        catch (err) {
+            if (!(err instanceof ConduytApiError && err.status === 409))
+                throw err;
+            if (attempt === 1) {
+                const current = (await client.get("/api/v1/settings"));
+                return formatResult({ conflict: true, message: err.message, expectedSettingsRevision: lastRevision, current: current?.data ?? null, hint: "the account settings changed twice while this change was being saved — read them again and call again" });
+            }
+        }
+    }
+    throw new Error("unreachable");
+}
 /**
  * Lifecycle v2 settings (master lead status + intake deals). The master lead
  * is the acquisition truth (first-write-wins source, one lifecycle status);

package/dist/tools/mailchimp.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ConduytClient } from "../client.js";
+/**
+ * Mailchimp audience sync (app 10-07/10-08, API key scope `integrations`, a non-default scope). Everything under
+ * /api/v1/integrations/mailchimp except the OAuth connect + callback, which are browser-only (the owner signs in to
+ * Mailchimp in a browser; there is no key-callable equivalent), and the Mailchimp webhook + cron routes, which
+ * belong to Mailchimp / the platform. Errors carry the server's message untouched; where the API sends a `code` it
+ * is in the error text.
+ */
+/** the admin routes' server budgets are 60 s (settings save: 45 s administrative deadline); the client default is 30 s */
+export declare const MAILCHIMP_ADMIN_TIMEOUT_MS = 60000;
+export declare function registerMailchimpTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/mailchimp.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { formatResult } from "../client.js";
+import { strictInput } from "./strict.js";
+/**
+ * Mailchimp audience sync (app 10-07/10-08, API key scope `integrations`, a non-default scope). Everything under
+ * /api/v1/integrations/mailchimp except the OAuth connect + callback, which are browser-only (the owner signs in to
+ * Mailchimp in a browser; there is no key-callable equivalent), and the Mailchimp webhook + cron routes, which
+ * belong to Mailchimp / the platform. Errors carry the server's message untouched; where the API sends a `code` it
+ * is in the error text.
+ */
+/** the admin routes' server budgets are 60 s (settings save: 45 s administrative deadline); the client default is 30 s */
+export const MAILCHIMP_ADMIN_TIMEOUT_MS = 60_000;
+const ADMIN_TIMEOUT_NOTE = " The call can take up to 60 s (a 60 s per-call timeout is used); if it still reports a timeout the server may have applied it: re-read conduyt_get_mailchimp_settings before repeating.";
+const NOT_CONNECTED = "404 Mailchimp is not connected for this account (connect it in the app: Settings > Integrations > Mailchimp, the OAuth step is browser-only); 409 the access was revoked (reconnect in the app).";
+export function registerMailchimpTools(server, client) {
+    strictInput(server.tool("conduyt_get_mailchimp_settings", "Read the account's Mailchimp connection (GET /api/v1/integrations/mailchimp/settings; scope integrations): the Mailchimp account, the audience, the source (one smart list or one tag), statusIfNew and unsubscribeSetsOptOut, and the sync status (backfill progress, pending pushes, last pushed, last webhook received, the plain-words error Mailchimp's last refusal left, and statusSweepBlocked when Conduyt's check of Mailchimp's unsubscribes is blocked). Answers `connected: false, status: \"not_connected\"` when there is no connection. Connecting itself is browser-only (OAuth).", {}, async () => formatResult(await client.get("/api/v1/integrations/mailchimp/settings"))));
+    strictInput(server.tool("conduyt_update_mailchimp_settings", "Configure the Mailchimp audience sync (PUT /api/v1/integrations/mailchimp/settings; scope integrations, settings:edit, active billing). Every field is optional and only the ones you send change; an unknown field is a 400. listId: the Mailchimp audience id (conduyt_list_mailchimp_audiences). source: { type: \"smart_list\" | \"tag\", id: uuid }, the contacts that go to the audience. statusIfNew: \"subscribed\" (default) or \"pending\" (Mailchimp sends a confirmation email). unsubscribeSetsOptOut (default true): a Mailchimp unsubscribe also opts the contact out of Conduyt email (Conduyt checks Mailchimp every 15 minutes; an unsubscribe reversed in Mailchimp before that check is not applied). A new audience gets Conduyt's audience webhook (the old one is removed) and a new audience or source starts the backfill; saving after a refusal resumes a stopped backfill. Answers the settings as conduyt_get_mailchimp_settings does. " + NOT_CONNECTED + " 400 an unknown tag / smart list / audience; 409 a sync pass is finishing or members are still being confirmed (try again in a few minutes); 502 Mailchimp refused." + ADMIN_TIMEOUT_NOTE, {
+        listId: z.string().min(1).optional().describe("Mailchimp audience id (conduyt_list_mailchimp_audiences)"),
+        source: z.object({
+            type: z.enum(["smart_list", "tag"]).describe("smart_list or tag"),
+            id: z.string().uuid().describe("The smart list or tag UUID"),
+        }).strict().optional().describe("The contacts that go to the audience: exactly one smart list or one tag"),
+        statusIfNew: z.enum(["subscribed", "pending"]).optional().describe("How new people are added: subscribed (default) or pending (Mailchimp sends a confirmation email)"),
+        unsubscribeSetsOptOut: z.boolean().optional().describe("Default true: a Mailchimp unsubscribe also opts the contact out of Conduyt email"),
+    }, async ({ listId, source, statusIfNew, unsubscribeSetsOptOut }) => {
+        if (listId === undefined && source === undefined && statusIfNew === undefined && unsubscribeSetsOptOut === undefined) {
+            throw new Error("Nothing to set. Pass at least one of listId, source, statusIfNew, unsubscribeSetsOptOut.");
+        }
+        // undefined fields are dropped by JSON.stringify, so only the ones given are sent
+        return formatResult(await client.put("/api/v1/integrations/mailchimp/settings", { listId, source, statusIfNew, unsubscribeSetsOptOut }, { timeoutMs: MAILCHIMP_ADMIN_TIMEOUT_MS }));
+    }));
+    strictInput(server.tool("conduyt_list_mailchimp_audiences", "List the connected Mailchimp account's audiences for choosing one (GET /api/v1/integrations/mailchimp/audiences; scope integrations): { data: [{ id, name, memberCount }] }. Use an id as listId in conduyt_update_mailchimp_settings. " + NOT_CONNECTED + " 502 Mailchimp refused.", {}, async () => formatResult(await client.get("/api/v1/integrations/mailchimp/audiences"))));
+    strictInput(server.tool("conduyt_mailchimp_push_now", "Run one Mailchimp sync pass now instead of waiting for the next minute (POST /api/v1/integrations/mailchimp/push; scope integrations, settings:edit, active billing): contacts newly in the source are queued, the backfill takes a step, due pushes are sent. Answers { data: { ran, result, settings } }; ran is false while another pass holds the connection or Mailchimp asked Conduyt to slow down (429), so check ran before assuming anything was pushed. " + NOT_CONNECTED + " 409 also when the connection is in error or not configured (choose an audience and a source first)." + ADMIN_TIMEOUT_NOTE, {}, async () => formatResult(await client.post("/api/v1/integrations/mailchimp/push", {}, { timeoutMs: MAILCHIMP_ADMIN_TIMEOUT_MS }))));
+    strictInput(server.tool("conduyt_mailchimp_retry_unsubscribes", "Try again, in one pass now, the unsubscribes Conduyt could not deliver to Mailchimp after its retries (POST /api/v1/integrations/mailchimp/unsubscribes/retry; scope integrations, settings:edit; no active billing needed, delivering an owed unsubscribe is never a paid effect). They are also retried daily. Answers { data: { ran, pending, delivered, undelivered, result, settings } }; pending is true when no pass could run (another pass holds the connection, Mailchimp asked to slow down, or the connection needs attention) and nothing was tried. One retry per account per 10 minutes: otherwise 429 with code retry_cooldown (the error text carries the minutes to wait). " + NOT_CONNECTED + ADMIN_TIMEOUT_NOTE, {}, async () => formatResult(await client.post("/api/v1/integrations/mailchimp/unsubscribes/retry", {}, { timeoutMs: MAILCHIMP_ADMIN_TIMEOUT_MS }))));
+    strictInput(server.tool("conduyt_mailchimp_reconcile_statuses", "Run the full reconciliation of Mailchimp's unsubscribes (POST /api/v1/integrations/mailchimp/reconcile-statuses; owner / admin key, scope integrations; no active billing needed). Use it when conduyt_get_mailchimp_settings shows statusSweepBlocked: more members than one page changed in the same second, so Conduyt's check is blocked. It reads every member Mailchimp shows as unsubscribed or cleaned up to that second and applies them (it ONLY ever opts people out), in up to 3 passes, and records a report; it never resumes the check on its own: review the report, then call conduyt_mailchimp_confirm_reconciliation. Starts the reconciliation (or resumes the one in progress) and runs one pass now; call again until done is true. Answers { data: { ran, done, reconciling, blocked, report, result, settings } }. restart=true replaces a COMPLETED run's report with a new run; without it a completed run is refused 409 with code reconciliation_completed (confirm it, or restart explicitly). Other refusals: 404 not connected; 409 access revoked, nothing blocked (\"Nothing to reconcile\"), or a sync pass running." + ADMIN_TIMEOUT_NOTE, {
+        restart: z.boolean().optional().describe("true replaces a completed run's report with a new run; without it a completed run answers 409 reconciliation_completed"),
+    }, async ({ restart }) => formatResult(await client.post("/api/v1/integrations/mailchimp/reconcile-statuses", { restart }, { timeoutMs: MAILCHIMP_ADMIN_TIMEOUT_MS }))));
+    strictInput(server.tool("conduyt_mailchimp_confirm_reconciliation", "Confirm a completed full reconciliation and resume Conduyt's check of Mailchimp's unsubscribes after the blocked second (POST /api/v1/integrations/mailchimp/confirm-reconciliation; owner / admin key, scope integrations): \"Confirm and resume\" on the manage page. Mailchimp cannot prove its member list was read completely, so this is the operator's explicit decision after reviewing the report from conduyt_mailchimp_reconcile_statuses; audited with the report's counts. Answers { data: { confirmed, report, settings } }. 404 not connected; 409 access revoked, nothing blocked, a reconciliation still running, or none completed since the block began (run conduyt_mailchimp_reconcile_statuses first)." + ADMIN_TIMEOUT_NOTE, {}, async () => formatResult(await client.post("/api/v1/integrations/mailchimp/confirm-reconciliation", {}, { timeoutMs: MAILCHIMP_ADMIN_TIMEOUT_MS }))));
+}

package/dist/tools/pipelines.d.ts

@@ -1,3 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ConduytClient } from "../client.js";
+/** The 10 palette colours a pipeline can be painted (API: PIPELINE_COLOR_PALETTE; any other value is a 400). */
+export declare const PIPELINE_COLORS: readonly ["#3845C9", "#43DFF6", "#2DD6B5", "#22C58B", "#9BD13B", "#F2B544", "#F07A2F", "#E6465A", "#FD88C0", "#956EFA"];
+/** The machine-readable codes the archive route answers with (the API puts `code` in the error body; the client carries it in the error text). */
+export declare const ARCHIVE_ERROR_CODES = "A refusal carries a machine-readable code in the error text: stale_settings_revision (409, settings changed since expectedSettingsRevision was read; nothing moved), target_not_open (409, the destination's first stage is won/lost), dpp_post_close (409, the DPP feed's Post-Close pipeline), archive_too_large (409, too many open deals for one call: move or close some first), target_archived (409, the destination was archived meanwhile), intake_target (409, enabled intake creates its cards in this pipeline), pipeline_archived (409), open_deals (409, open deals but no moveOpenDealsTo), default_pipeline (409), stage_requirements (409, a deal fails the destination's stage-entry rules; nothing moved), archive_raced (409, retry), pipeline_automation_only (403). Archiving a pipeline that is already archived is idempotent: { archived: true, alreadyArchived: true }. The message is the server's, never swallowed. The call can take up to 75 s (a 75 s per-call timeout is used); if it still reports a timeout the archive may have committed: re-read with conduyt_list_pipelines / conduyt_list_archived_pipelines before retrying (a retry of a committed archive answers alreadyArchived, but its open deals have already moved).";
+/** above the archive route's 60 s transaction (up to 500 deal moves) plus post-commit events; the client default is 30 s */
+export declare const ARCHIVE_PIPELINE_TIMEOUT_MS = 75000;
 export declare function registerPipelineTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/pipelines.js

@@ -1,14 +1,27 @@
 import { z } from "zod";
 import { formatResult } from "../client.js";
+import { strictInput } from "./strict.js";
+/** The 10 palette colours a pipeline can be painted (API: PIPELINE_COLOR_PALETTE; any other value is a 400). */
+export const PIPELINE_COLORS = ["#3845C9", "#43DFF6", "#2DD6B5", "#22C58B", "#9BD13B", "#F2B544", "#F07A2F", "#E6465A", "#FD88C0", "#956EFA"];
+const pipelineColor = z.enum(PIPELINE_COLORS);
+/** The machine-readable codes the archive route answers with (the API puts `code` in the error body; the client carries it in the error text). */
+export const ARCHIVE_ERROR_CODES = "A refusal carries a machine-readable code in the error text: stale_settings_revision (409, settings changed since expectedSettingsRevision was read; nothing moved), target_not_open (409, the destination's first stage is won/lost), dpp_post_close (409, the DPP feed's Post-Close pipeline), archive_too_large (409, too many open deals for one call: move or close some first), target_archived (409, the destination was archived meanwhile), intake_target (409, enabled intake creates its cards in this pipeline), pipeline_archived (409), open_deals (409, open deals but no moveOpenDealsTo), default_pipeline (409), stage_requirements (409, a deal fails the destination's stage-entry rules; nothing moved), archive_raced (409, retry), pipeline_automation_only (403). Archiving a pipeline that is already archived is idempotent: { archived: true, alreadyArchived: true }. The message is the server's, never swallowed. The call can take up to 75 s (a 75 s per-call timeout is used); if it still reports a timeout the archive may have committed: re-read with conduyt_list_pipelines / conduyt_list_archived_pipelines before retrying (a retry of a committed archive answers alreadyArchived, but its open deals have already moved).";
+/** above the archive route's 60 s transaction (up to 500 deal moves) plus post-commit events; the client default is 30 s */
+export const ARCHIVE_PIPELINE_TIMEOUT_MS = 75_000;
 export function registerPipelineTools(server, client) {
-    server.tool("conduyt_list_pipelines", "List all sales pipelines with their stages. Use this to discover pipeline and stage UUIDs before creating or moving deals.", {}, async () => {
+    server.tool("conduyt_list_pipelines", "List all active sales pipelines with their stages. Use this to discover pipeline and stage UUIDs before creating or moving deals. Each pipeline carries color (one of the 10 palette hex colours, or null until the settings page saves one), automationOnly and sortOrder (the board-menu order); an archived pipeline's pre-archive name is archivedFromName (see conduyt_list_archived_pipelines).", {}, async () => {
         const result = await client.get("/api/v1/pipelines");
         return formatResult(result);
     });
+    strictInput(server.tool("conduyt_list_archived_pipelines", "List the ARCHIVED pipelines (GET /api/v1/pipelines?archived=true; owner / admin key only; newest first, max 200): [{ id, name (the pre-archive name), archivedName, color, archivedAt, openDeals, stageCount }]. Archived pipelines are hidden from conduyt_list_pipelines. Bring one back with conduyt_restore_pipeline.", {}, async () => {
+        const result = await client.get("/api/v1/pipelines?archived=true");
+        return formatResult(result);
+    }));
     server.tool("conduyt_create_pipeline", "Create a new sales pipeline, optionally with its full set of stages in one call. If stages are omitted, default New/Won/Lost stages are created. There is no fixed limit on stage count — pass as many as your funnel needs (e.g. eight active stages plus 'On Hold' and 'Declined/Dead').", {
         name: z.string().describe("Pipeline name (e.g. 'New Business Book')"),
         description: z.string().optional().describe("Optional pipeline description"),
         isDefault: z.boolean().optional().describe("Make this the account's default pipeline"),
+        color: pipelineColor.optional().describe("Pipeline colour: one of the 10 palette hex colours (case-insensitive). Omit to leave it unset."),
         stages: z
             .array(z.object({
             name: z.string().describe("Stage name (e.g. 'Quote Sent')"),
@@ -20,8 +33,10 @@ export function registerPipelineTools(server, client) {
         }))
             .optional()
             .describe("Ordered list of stages to create with the pipeline. A stage cannot be both isWon and isLost."),
-    }, async ({ name, description, isDefault, stages }) => {
+    }, async ({ name, description, isDefault, color, stages }) => {
         const body = { name };
+        if (color !== undefined)
+            body.color = color;
         if (description !== undefined)
             body.description = description;
         if (isDefault !== undefined)
@@ -35,21 +50,46 @@ export function registerPipelineTools(server, client) {
         const result = await client.post("/api/v1/pipelines", body);
         return formatResult(result);
     });
-    server.tool("conduyt_update_pipeline", "Update a pipeline's name, description, or default flag. To add/edit/remove stages, use the stage tools.", {
+    strictInput(server.tool("conduyt_update_pipeline", "Update a pipeline's name, description, default flag, colour, board-menu position (sortOrder) or automationOnly flag (owner/admin key only). An archived pipeline cannot be edited (410). An automation-only pipeline's cards are moved and edited only by automations, API keys and owners / admins; a member's edit is refused with 403 pipeline_automation_only. conduyt_list_pipelines returns the flag on each pipeline. To add/edit/remove stages, use the stage tools.", {
         id: z.string().describe("Pipeline UUID"),
         name: z.string().optional().describe("Updated pipeline name"),
         description: z.string().optional().describe("Updated description"),
         isDefault: z.boolean().optional().describe("Set as the account's default pipeline"),
+        automationOnly: z.boolean().optional().describe("Automation-only pipeline: only automations, API keys and owners / admins move or edit its cards; a member's edit is refused with 403 pipeline_automation_only. Owner / admin only."),
+        color: pipelineColor.optional().describe("Pipeline colour: one of the 10 palette hex colours (any other value is a 400)."),
+        sortOrder: z.number().int().min(0).max(2147483647).optional().describe("Board-menu position (0-based, non-negative integer). To reorder every pipeline at once use conduyt_reorder_pipelines."),
     }, async ({ id, ...updates }) => {
         const result = await client.patch(`/api/v1/pipelines/${id}`, updates);
         return formatResult(result);
-    });
+    }));
     server.tool("conduyt_delete_pipeline", "Delete a pipeline. Deals in the pipeline must be moved or removed first. Cannot delete the default or an archived pipeline.", {
         id: z.string().describe("Pipeline UUID to delete"),
     }, async ({ id }) => {
         const result = await client.del(`/api/v1/pipelines/${id}`);
         return formatResult(result);
     });
+    strictInput(server.tool("conduyt_archive_pipeline", "Archive a pipeline (POST /api/v1/pipelines/{id}/archive; owner / admin key). The pipeline is renamed with the archived prefix, never deleted: its closed (won / lost) deals stay in it as history and conduyt_restore_pipeline brings it back. Every OPEN deal moves in the same transaction to moveOpenDealsTo's first rep-facing stage through the normal stage-entry rules; any refusal aborts the whole thing (nothing moves, nothing is archived). Pass moveOpenDealsTo=null only when the pipeline has no open deals. The default pipeline cannot be archived. To guard against settings that changed since you looked, read conduyt_get_settings_revision right before and pass its settingsRevision as expectedSettingsRevision. " + ARCHIVE_ERROR_CODES, {
+        id: z.string().uuid().describe("Pipeline UUID to archive"),
+        moveOpenDealsTo: z.string().uuid().nullable().describe("Pipeline UUID the open deals move to (another active pipeline whose first stage is open), or null when there are no open deals"),
+        expectedSettingsRevision: z.string().regex(/^\d+$/).optional().describe("The settingsRevision from conduyt_get_settings_revision, read right before; the archive is refused 409 stale_settings_revision when settings changed since"),
+    }, async ({ id, moveOpenDealsTo, expectedSettingsRevision }) => {
+        // an undefined expectedSettingsRevision is dropped by JSON.stringify
+        const result = await client.post(`/api/v1/pipelines/${id}/archive`, { moveOpenDealsTo, expectedSettingsRevision }, { timeoutMs: ARCHIVE_PIPELINE_TIMEOUT_MS });
+        return formatResult(result);
+    }));
+    strictInput(server.tool("conduyt_restore_pipeline", "Restore an archived pipeline (POST /api/v1/pipelines/{id}/restore; owner / admin key): it loses the archived prefix, is appended at the end of the board-menu order, is never the default, and its stages and closed deals come back with it. 404 when the pipeline is not an archived one of this account; 409 name_taken (code in the error text) when an active pipeline already has its name (rename that one first); 403 PLAN_LIMIT_REACHED when the plan's pipeline limit is full (a restore counts like a create).", {
+        id: z.string().uuid().describe("Archived pipeline UUID (conduyt_list_archived_pipelines)"),
+    }, async ({ id }) => {
+        const result = await client.post(`/api/v1/pipelines/${id}/restore`, {});
+        return formatResult(result);
+    }));
+    strictInput(server.tool("conduyt_reorder_pipelines", "Set the board-menu order of the active pipelines in one transaction (POST /api/v1/pipelines/reorder; owner / admin key). order must list EVERY active pipeline exactly once (400 otherwise); expectedRevision is the current order as the pipeline ids by position, comma-joined (what the previous reorder answered as `revision`): 409 order_changed (with the current revision) when the order moved since, nothing written. Answers { order, revision }.", {
+        order: z.array(z.string().uuid()).min(1).max(1000).describe("Every active pipeline id, in the new order"),
+        expectedRevision: z.string().min(1).describe("The order you last read: pipeline ids by position, comma-joined (lowercase)"),
+    }, async ({ order, expectedRevision }) => {
+        const result = await client.post("/api/v1/pipelines/reorder", { order, expectedRevision });
+        return formatResult(result);
+    }));
     server.tool("conduyt_create_stage", "Add a new stage to an existing pipeline. The stage is appended after the current last stage. Use this to extend a funnel (e.g. add 'On Hold' or 'Declined/Dead').", {
         pipelineId: z.string().describe("Pipeline UUID to add the stage to"),
         name: z.string().describe("Stage name"),
@@ -80,11 +120,27 @@ export function registerPipelineTools(server, client) {
         const result = await client.patch(`/api/v1/pipelines/${pipelineId}/stages/${stageId}`, updates);
         return formatResult(result);
     });
-    server.tool("conduyt_delete_stage", "Delete a stage from a pipeline. The stage must be empty (no deals) — move or reassign deals first.", {
+    strictInput(server.tool("conduyt_reorder_stages", "Set a pipeline's column order in one transaction (POST /api/v1/pipelines/{id}/stages/reorder; owner / admin key). order must list EVERY stage of the pipeline exactly once and must not put a system holding stage first that was not first (400 otherwise); expectedRevision is the current order as the stage ids by position, comma-joined: 409 order_changed (with the current revision) when it moved since, 409 pipeline_archived when the pipeline was archived meanwhile. Answers { order, revision }.", {
+        pipelineId: z.string().uuid().describe("Pipeline UUID"),
+        order: z.array(z.string().uuid()).min(1).max(1000).describe("Every stage id of the pipeline, in the new order"),
+        expectedRevision: z.string().min(1).describe("The order you last read: stage ids by position, comma-joined (lowercase)"),
+    }, async ({ pipelineId, order, expectedRevision }) => {
+        const result = await client.post(`/api/v1/pipelines/${pipelineId}/stages/reorder`, { order, expectedRevision });
+        return formatResult(result);
+    }));
+    strictInput(server.tool("conduyt_delete_stage", "Delete a stage from a pipeline. Strict input: the guards are spelled moveTo and expectedSettingsRevision, any other spelling (move_to, expected_settings_revision, a typo) is InvalidParams and nothing is deleted. The stage must be empty (no deals) unless moveTo names another stage of the same pipeline (same won / lost setting, not a system stage): its live deals then move there and the stage is deleted in one transaction. A stage a soft-deleted deal still points at is refused. Pass expectedSettingsRevision (the settingsRevision from conduyt_get_settings_revision, read right before) to refuse the delete when settings changed since you read them; the answer is then { id, deleted: true, settingsRevision } with the revision after the delete. A refusal carries a machine-readable code in the error text and the server's message, never swallowed: stale_settings_revision (409), pipeline_archived (409), intake_target (409, enabled intake routes deals into this stage); other 409s (DPP status map, unattended-lead automations, deals that used the stage) have no code but name the cause.", {
         pipelineId: z.string().describe("Pipeline UUID"),
         stageId: z.string().describe("Stage UUID to delete"),
-    }, async ({ pipelineId, stageId }) => {
-        const result = await client.del(`/api/v1/pipelines/${pipelineId}/stages/${stageId}`);
+        moveTo: z.string().uuid().optional().describe("Another stage of the same pipeline the live deals move to (sent as move_to)"),
+        expectedSettingsRevision: z.string().regex(/^\d+$/).optional().describe("The settingsRevision from conduyt_get_settings_revision; a stale one is refused 409 stale_settings_revision (sent as expected_settings_revision)"),
+    }, async ({ pipelineId, stageId, moveTo, expectedSettingsRevision }) => {
+        const qs = new URLSearchParams();
+        if (moveTo !== undefined)
+            qs.set("move_to", moveTo);
+        if (expectedSettingsRevision !== undefined)
+            qs.set("expected_settings_revision", expectedSettingsRevision);
+        const q = qs.toString();
+        const result = await client.del(`/api/v1/pipelines/${pipelineId}/stages/${stageId}` + (q ? "?" + q : ""));
         return formatResult(result);
-    });
+    }));
 }

package/dist/tools/status-metadata.d.ts

@@ -0,0 +1,11 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ConduytClient } from "../client.js";
+/**
+ * Status metadata (the status taxonomy rows that attach a lead-status code + bucket to a pipeline STAGE; app 10-08
+ * pipeline settings). One row per stage and code. Updates and deletes take the row's updatedAt as `expectedUpdatedAt`
+ * (the version you read) so a row someone else changed or moved meanwhile is refused instead of overwritten.
+ */
+export declare const LIFECYCLE_STAGES: readonly ["pre_sale", "sale", "underwriting", "active", "resolution", "terminal"];
+/** above the import route's 20 s transaction budget plus lock waits; the client default is 30 s */
+export declare const STATUS_METADATA_IMPORT_TIMEOUT_MS = 60000;
+export declare function registerStatusMetadataTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/status-metadata.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { formatResult } from "../client.js";
+import { strictInput } from "./strict.js";
+/**
+ * Status metadata (the status taxonomy rows that attach a lead-status code + bucket to a pipeline STAGE; app 10-08
+ * pipeline settings). One row per stage and code. Updates and deletes take the row's updatedAt as `expectedUpdatedAt`
+ * (the version you read) so a row someone else changed or moved meanwhile is refused instead of overwritten.
+ */
+export const LIFECYCLE_STAGES = ["pre_sale", "sale", "underwriting", "active", "resolution", "terminal"];
+/** above the import route's 20 s transaction budget plus lock waits; the client default is 30 s */
+export const STATUS_METADATA_IMPORT_TIMEOUT_MS = 60_000;
+const SLUG_RE = /^[a-z0-9][a-z0-9_]{0,79}$/;
+const slug = z.string().regex(SLUG_RE, "lowercase machine slug: letters, numbers and underscores, max 80");
+const METADATA_ERRORS = "A refusal carries a machine-readable code in the error text where the API sends one: status_metadata_not_found (404, no such row for you), metadata_changed (409, the row changed or moved since expectedUpdatedAt; the error text carries the `current` row to reload), pipeline_archived (409, the stage's pipeline was archived meanwhile), stage_not_found (404), drip_track_not_found (404). A duplicate stage + code is a 409 without a code. The message is the server's, never swallowed.";
+export function registerStatusMetadataTools(server, client) {
+    strictInput(server.tool("conduyt_list_status_metadata", "List the status metadata rows (GET /api/v1/status-metadata; settings:view), each { id, stageId, code, bucket, lifecycleStage, dripEligible, dripTrackId, isTerminal, notes, updatedAt, stage, dripTrack }. Filter by stageId, bucket or code. updatedAt is the version to pass back as expectedUpdatedAt on update / delete. Rows of pipelines your key cannot see are left out.", {
+        stageId: z.string().uuid().optional().describe("Only this stage's rows"),
+        bucket: z.string().optional().describe("Only this bucket"),
+        code: z.string().optional().describe("Only this code"),
+    }, async ({ stageId, bucket, code }) => {
+        const qs = new URLSearchParams();
+        if (stageId !== undefined)
+            qs.set("stageId", stageId);
+        if (bucket !== undefined)
+            qs.set("bucket", bucket);
+        if (code !== undefined)
+            qs.set("code", code);
+        const q = qs.toString();
+        return formatResult(await client.get("/api/v1/status-metadata" + (q ? "?" + q : "")));
+    }));
+    strictInput(server.tool("conduyt_get_status_metadata", "Get one status metadata row with its stage and drip track (GET /api/v1/status-metadata/{id}); 404 status_metadata_not_found. Its updatedAt is the expectedUpdatedAt for an update or delete.", {
+        id: z.string().uuid().describe("Status metadata UUID"),
+    }, async ({ id }) => formatResult(await client.get(`/api/v1/status-metadata/${id}`))));
+    strictInput(server.tool("conduyt_create_status_metadata", "Create a status metadata row for a stage (POST /api/v1/status-metadata; settings:edit, active billing). code and bucket are lowercase machine slugs (letters, numbers, underscores, max 80); one row per stage and code (a duplicate is a 409). lifecycleStage is one of pre_sale, sale, underwriting, active, resolution, terminal. " + METADATA_ERRORS, {
+        stageId: z.string().uuid().describe("Pipeline stage UUID the row attaches to"),
+        code: slug.describe("Status code slug, e.g. 'appt_set'"),
+        bucket: slug.describe("Bucket slug, e.g. 'working'"),
+        lifecycleStage: z.enum(LIFECYCLE_STAGES).nullable().optional().describe("Lifecycle stage, or null"),
+        dripEligible: z.boolean().optional().describe("Eligible for a drip track"),
+        dripTrackId: z.string().uuid().nullable().optional().describe("Drip track UUID, or null"),
+        isTerminal: z.boolean().optional().describe("Terminal status"),
+        notes: z.string().max(5000).nullable().optional().describe("Free-text notes"),
+    }, 
+    // undefined fields are dropped by JSON.stringify, so only the ones given are sent
+    async ({ stageId, code, bucket, lifecycleStage, dripEligible, dripTrackId, isTerminal, notes }) => formatResult(await client.post("/api/v1/status-metadata", { stageId, code, bucket, lifecycleStage, dripEligible, dripTrackId, isTerminal, notes }))));
+    strictInput(server.tool("conduyt_update_status_metadata", "Update a status metadata row (PATCH /api/v1/status-metadata/{id}; settings:edit, active billing). Only the fields you pass change; at least one is needed (400 otherwise). Pass expectedUpdatedAt (the row's updatedAt as you read it) to refuse the update when the row was changed or moved to another stage since: 409 metadata_changed with the current row. " + METADATA_ERRORS, {
+        id: z.string().uuid().describe("Status metadata UUID"),
+        expectedUpdatedAt: z.string().datetime({ offset: true }).optional().describe("The row's updatedAt as you read it (ISO date); a stale one is refused 409 metadata_changed"),
+        stageId: z.string().uuid().optional().describe("Move the row to another stage"),
+        code: slug.optional().describe("Status code slug"),
+        bucket: slug.optional().describe("Bucket slug"),
+        lifecycleStage: z.enum(LIFECYCLE_STAGES).nullable().optional().describe("Lifecycle stage, or null"),
+        dripEligible: z.boolean().optional().describe("Eligible for a drip track"),
+        dripTrackId: z.string().uuid().nullable().optional().describe("Drip track UUID, or null"),
+        isTerminal: z.boolean().optional().describe("Terminal status"),
+        notes: z.string().max(5000).nullable().optional().describe("Free-text notes"),
+    }, async ({ id, expectedUpdatedAt, stageId, code, bucket, lifecycleStage, dripEligible, dripTrackId, isTerminal, notes }) => formatResult(await client.patch(`/api/v1/status-metadata/${id}`, { expectedUpdatedAt, stageId, code, bucket, lifecycleStage, dripEligible, dripTrackId, isTerminal, notes }))));
+    strictInput(server.tool("conduyt_delete_status_metadata", "Delete a status metadata row (DELETE /api/v1/status-metadata/{id}; settings:edit, active billing). Strict input: the guard is spelled expectedUpdatedAt, any other spelling (expected_updated_at, a typo) is InvalidParams and nothing is deleted. Pass expectedUpdatedAt (the row's updatedAt as you read it) to refuse the delete when the row changed or moved since: 409 metadata_changed with the current row. " + METADATA_ERRORS, {
+        id: z.string().uuid().describe("Status metadata UUID"),
+        expectedUpdatedAt: z.string().datetime({ offset: true }).optional().describe("The row's updatedAt as you read it (ISO date); sent as expected_updated_at"),
+    }, async ({ id, expectedUpdatedAt }) => {
+        const result = await client.del(`/api/v1/status-metadata/${id}` + (expectedUpdatedAt !== undefined ? "?expected_updated_at=" + encodeURIComponent(expectedUpdatedAt) : ""));
+        return formatResult(result ?? { deleted: true, id });
+    }));
+    strictInput(server.tool("conduyt_import_status_metadata", "Import status metadata rows in one set-based call (POST /api/v1/status-metadata/import; owner / admin key, active billing; max 1000 items). mode \"merge\" (default) upserts the valid items and reports the rest in errors[]; mode \"replace\" replaces the rows of the ACTIVE pipelines with the items (an EMPTY items list with replace would delete them all and is refused before any request) and, if any item is invalid, imports nothing (imported 0, every item skipped, errors[] says which). Rows of archived pipelines are kept by a replace. Answers { imported, skipped, errors: [{ stageId, reason }] }; check errors even on a 200. An item naming a stage of an ARCHIVED pipeline refuses the whole import: 409 pipeline_archived with the stageIds. Items name a drip track by dripTrackName (not id); an item with a key outside stageId, code, bucket, lifecycleStage, dripEligible, dripTrackName, isTerminal, notes (a misspelled isTerminal, say) is refused as InvalidParams before any request, never stored with defaults. The call can take up to 60 s (a 60 s per-call timeout is used); if it still reports a timeout, the import may have been applied: re-list the rows with conduyt_list_status_metadata before importing again.", {
+        mode: z.enum(["merge", "replace"]).optional().describe("merge (default) or replace"),
+        items: z.array(z.object({
+            stageId: z.string().uuid().describe("Pipeline stage UUID"),
+            code: slug.describe("Status code slug"),
+            bucket: slug.describe("Bucket slug"),
+            lifecycleStage: z.enum(LIFECYCLE_STAGES).nullable().optional().describe("Lifecycle stage, or null"),
+            dripEligible: z.boolean().optional().describe("Eligible for a drip track (default false)"),
+            dripTrackName: slug.nullable().optional().describe("Drip track NAME (slug), or null"),
+            isTerminal: z.boolean().optional().describe("Terminal status (default false)"),
+            notes: z.string().max(5000).nullable().optional().describe("Free-text notes"),
+        }).strict()).max(1000).describe("The rows, max 1000; one per stageId and one per code within the call"),
+    }, async ({ mode, items }) => {
+        // mode replace with no items deletes the whole active taxonomy on the server: refused here, before any request
+        if (mode === "replace" && items.length === 0) {
+            throw new Error("mode replace with no items would delete every status metadata row of the active pipelines; refused. Pass the rows to keep (at least one), or use mode merge.");
+        }
+        return formatResult(await client.post("/api/v1/status-metadata/import", { ...(mode !== undefined ? { mode } : {}), items }, { timeoutMs: STATUS_METADATA_IMPORT_TIMEOUT_MS }));
+    }));
+}

package/dist/tools/strict.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The SDK wraps a tool's raw Zod shape in a NON-strict object, so an argument the tool does not declare (a typo, or a
+ * field the API does not take, e.g. lostReasonAllowOther) is silently stripped and the call "succeeds" without it. For a
+ * tool where that would widen or drop a change, `strictInput(server.tool(...))` swaps the registered input schema for
+ * its strict form: an unknown key is an InvalidParams error and the advertised JSON schema says additionalProperties: false.
+ * (The SDK's server.tool() only takes a raw shape, so the swap is done on the registered tool.) A server stub that
+ * returns nothing is left alone.
+ */
+export declare function strictInput<T>(tool: T): T;

package/dist/tools/strict.js

@@ -0,0 +1,19 @@
+import { z as zod } from "zod";
+/**
+ * The SDK wraps a tool's raw Zod shape in a NON-strict object, so an argument the tool does not declare (a typo, or a
+ * field the API does not take, e.g. lostReasonAllowOther) is silently stripped and the call "succeeds" without it. For a
+ * tool where that would widen or drop a change, `strictInput(server.tool(...))` swaps the registered input schema for
+ * its strict form: an unknown key is an InvalidParams error and the advertised JSON schema says additionalProperties: false.
+ * (The SDK's server.tool() only takes a raw shape, so the swap is done on the registered tool.) A server stub that
+ * returns nothing is left alone.
+ */
+export function strictInput(tool) {
+    const t = tool;
+    if (t && typeof t.inputSchema?.strict === "function")
+        t.inputSchema = t.inputSchema.strict();
+    // a tool registered with an EMPTY raw shape gets the SDK's own non-strict empty object (zod mini, no .strict()), which strips any
+    // argument (a `dryRun: true` sent to a push or a confirm would be silently dropped): swap in an explicit strict empty object
+    else if (t && typeof t === "object" && "handler" in t && Object.keys(t.inputSchema?.shape ?? {}).length === 0)
+        t.inputSchema = zod.object({}).strict();
+    return tool;
+}

package/package.json

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

package/scripts/coverage-manifest.json

@@ -380,6 +380,11 @@
       "status": "planned",
       "reason": "email warm-up engine surfaces"
     },
+    {
+      "match": "/api/v1/integrations/mailchimp/oauth",
+      "status": "excluded",
+      "reason": "browser-only OAuth connect + callback: the owner signs in to Mailchimp in a browser and the callback is a redirect, nothing a key can do"
+    },
     {
       "match": "/api/v1/integrations",
       "status": "planned",

package/scripts/coverage-matrix.json

@@ -1,11 +1,11 @@
 {
-  "generatedAt": "2026-10-07T06:35:55.228Z",
-  "toolCount": 302,
-  "totalEndpoints": 1047,
+  "generatedAt": "2026-10-09T01:29:38.747Z",
+  "toolCount": 328,
+  "totalEndpoints": 1064,
   "counts": {
-    "covered": 276,
+    "covered": 294,
     "excluded": 318,
-    "planned": 453,
+    "planned": 452,
     "uncategorized": 0
   },
   "matrix": {
@@ -1773,6 +1773,10 @@
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
     },
+    "GET /api/v1/cron/process-google-ads-conversions": {
+      "status": "excluded",
+      "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
+    },
     "GET /api/v1/cron/process-import-side-effects": {
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
@@ -1789,6 +1793,10 @@
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
     },
+    "GET /api/v1/cron/process-mailchimp-sync": {
+      "status": "excluded",
+      "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
+    },
     "GET /api/v1/cron/process-message-insights": {
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
@@ -2206,8 +2214,10 @@
       "reason": "deal subroutes beyond core CRUD (history, files, links)"
     },
     "GET /api/v1/deals/inspection": {
-      "status": "planned",
-      "reason": "deal subroutes beyond core CRUD (history, files, links)"
+      "status": "covered",
+      "tools": [
+        "conduyt_pipeline_health"
+      ]
     },
     "POST /api/v1/deals/probabilities": {
       "status": "planned",
@@ -2977,6 +2987,56 @@
       "status": "planned",
       "reason": "integration management"
     },
+    "GET /api/v1/integrations/mailchimp/audiences": {
+      "status": "covered",
+      "tools": [
+        "conduyt_list_mailchimp_audiences"
+      ]
+    },
+    "POST /api/v1/integrations/mailchimp/confirm-reconciliation": {
+      "status": "covered",
+      "tools": [
+        "conduyt_mailchimp_confirm_reconciliation"
+      ]
+    },
+    "GET /api/v1/integrations/mailchimp/oauth/callback": {
+      "status": "excluded",
+      "reason": "browser-only OAuth connect + callback: the owner signs in to Mailchimp in a browser and the callback is a redirect, nothing a key can do"
+    },
+    "GET /api/v1/integrations/mailchimp/oauth/install": {
+      "status": "excluded",
+      "reason": "browser-only OAuth connect + callback: the owner signs in to Mailchimp in a browser and the callback is a redirect, nothing a key can do"
+    },
+    "POST /api/v1/integrations/mailchimp/push": {
+      "status": "covered",
+      "tools": [
+        "conduyt_mailchimp_push_now"
+      ]
+    },
+    "POST /api/v1/integrations/mailchimp/reconcile-statuses": {
+      "status": "covered",
+      "tools": [
+        "conduyt_mailchimp_reconcile_statuses"
+      ]
+    },
+    "GET /api/v1/integrations/mailchimp/settings": {
+      "status": "covered",
+      "tools": [
+        "conduyt_get_mailchimp_settings"
+      ]
+    },
+    "PUT /api/v1/integrations/mailchimp/settings": {
+      "status": "covered",
+      "tools": [
+        "conduyt_update_mailchimp_settings"
+      ]
+    },
+    "POST /api/v1/integrations/mailchimp/unsubscribes/retry": {
+      "status": "covered",
+      "tools": [
+        "conduyt_mailchimp_retry_unsubscribes"
+      ]
+    },
     "GET /api/v1/integrations/slack/channels": {
       "status": "planned",
       "reason": "integration management"
@@ -3204,7 +3264,8 @@
     "GET /api/v1/pipelines": {
       "status": "covered",
       "tools": [
-        "conduyt_list_pipelines"
+        "conduyt_list_pipelines",
+        "conduyt_list_archived_pipelines"
       ]
     },
     "POST /api/v1/pipelines": {
@@ -3229,6 +3290,18 @@
         "conduyt_delete_pipeline"
       ]
     },
+    "POST /api/v1/pipelines/:id/archive": {
+      "status": "covered",
+      "tools": [
+        "conduyt_archive_pipeline"
+      ]
+    },
+    "POST /api/v1/pipelines/:id/restore": {
+      "status": "covered",
+      "tools": [
+        "conduyt_restore_pipeline"
+      ]
+    },
     "GET /api/v1/pipelines/:id/stages": {
       "status": "planned",
       "reason": "pipeline subroutes beyond core CRUD"
@@ -3255,6 +3328,18 @@
         "conduyt_delete_stage"
       ]
     },
+    "POST /api/v1/pipelines/:id/stages/reorder": {
+      "status": "covered",
+      "tools": [
+        "conduyt_reorder_stages"
+      ]
+    },
+    "POST /api/v1/pipelines/reorder": {
+      "status": "covered",
+      "tools": [
+        "conduyt_reorder_pipelines"
+      ]
+    },
     "GET /api/v1/playbook-enrollments": {
       "status": "planned",
       "reason": "playbook enrollment surfaces"
@@ -3864,6 +3949,10 @@
     "GET /api/v1/settings": {
       "status": "covered",
       "tools": [
+        "conduyt_get_stage_rules",
+        "conduyt_get_deal_card_fields",
+        "conduyt_get_settings_revision",
+        "conduyt_get_pipeline_rot_days",
         "conduyt_get_contact_table_defaults",
         "conduyt_set_contact_table_defaults",
         "conduyt_get_call_recording_settings",
@@ -4285,24 +4374,34 @@
       "reason": "SAML/SSO configuration + protocol endpoints; interactive/IdP-facing"
     },
     "GET /api/v1/status-metadata": {
-      "status": "excluded",
-      "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
+      "status": "covered",
+      "tools": [
+        "conduyt_list_status_metadata"
+      ]
     },
     "POST /api/v1/status-metadata": {
-      "status": "excluded",
-      "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
+      "status": "covered",
+      "tools": [
+        "conduyt_create_status_metadata"
+      ]
     },
     "GET /api/v1/status-metadata/:id": {
-      "status": "excluded",
-      "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
+      "status": "covered",
+      "tools": [
+        "conduyt_get_status_metadata"
+      ]
     },
     "PATCH /api/v1/status-metadata/:id": {
-      "status": "excluded",
-      "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
+      "status": "covered",
+      "tools": [
+        "conduyt_update_status_metadata"
+      ]
     },
     "DELETE /api/v1/status-metadata/:id": {
-      "status": "excluded",
-      "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
+      "status": "covered",
+      "tools": [
+        "conduyt_delete_status_metadata"
+      ]
     },
     "GET /api/v1/status-metadata/buckets": {
       "status": "excluded",
@@ -4321,8 +4420,10 @@
       "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
     },
     "POST /api/v1/status-metadata/import": {
-      "status": "excluded",
-      "reason": "UI enum/metadata hydration for dashboard pickers; tools embed their enums"
+      "status": "covered",
+      "tools": [
+        "conduyt_import_status_metadata"
+      ]
     },
     "POST /api/v1/support/requests": {
       "status": "excluded",
@@ -4599,6 +4700,14 @@
       "status": "excluded",
       "reason": "inbound provider callback receivers (Twilio/Resend/etc.), not client-callable"
     },
+    "GET /api/v1/webhooks/mailchimp/:connectionId": {
+      "status": "excluded",
+      "reason": "inbound provider callback receivers (Twilio/Resend/etc.), not client-callable"
+    },
+    "POST /api/v1/webhooks/mailchimp/:connectionId": {
+      "status": "excluded",
+      "reason": "inbound provider callback receivers (Twilio/Resend/etc.), not client-callable"
+    },
     "GET /api/v1/webhooks/manage": {
       "status": "covered",
       "tools": [