conduyt-mcp 4.71.1 → 4.72.1

package/README.md

@@ -2,7 +2,7 @@
 
 MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-accessible tools. Covers the core CRM surface (contacts, deals, pipelines, custom fields, automations, messaging, and more); use `conduyt_api_catalog` to discover the full set of 500+ REST endpoints.
 
-## 292 Tools
+## 299 Tools
 
 ### Discovery
 | Tool | Description |
@@ -74,14 +74,20 @@ MCP server for [Conduyt CRM](https://conduyt.app) — expose your CRM as AI-acce
 | `conduyt_workflow_simulate` | Dry-run a workflow against a real or stub contact — step-by-step trace with compliance and provider checks |
 | `conduyt_workflow_promote` | Safely publish a workflow — validates first, refuses if errors exist |
 
-### Email Sequences
+### Sequences (Email and SMS)
 | Tool | Description |
 |------|-------------|
-| `conduyt_list_sequences` | List email sequences with enrollment stats |
-| `conduyt_get_sequence` | Get sequence with steps and stats |
-| `conduyt_create_sequence` | Create a new email sequence with steps |
-| `conduyt_enroll_in_sequence` | Enroll contacts into a sequence |
-| `conduyt_unenroll_from_sequence` | Remove a contact from a sequence |
+| `conduyt_list_sequences` | List Email and SMS sequences: filter by type, On/Off, archived; view=summary for a light row each |
+| `conduyt_get_sequence` | One sequence: steps, sender, send window, stop rules, enrollment switches, people per run status |
+| `conduyt_create_sequence` | Create an Email or SMS sequence from saved templates (type fixed at creation, created Off unless isActive) |
+| `conduyt_update_sequence` | Change steps and settings, turn On or Off, archive or restore |
+| `conduyt_list_sequence_senders` | Who can be a sequence's sender, per channel (address for email, assigned line for SMS) |
+| `conduyt_preflight_sequence_enrollment` | Check contacts before enrolling: eligible, skipped and why, blockers |
+| `conduyt_pick_sequence_list` | Who of a Smart View or Smart List goes in next, with a cursor to continue |
+| `conduyt_enroll_in_sequence` | Enroll contacts into a sequence (up to 500 per call) |
+| `conduyt_unenroll_from_sequence` | Remove a contact from a sequence (the run ends as removed) |
+| `conduyt_list_sequence_enrollments` | The runs in a sequence: status, endedReason, current step, engagement; all_active for every live run |
+| `conduyt_get_sequence_stats` | Sends, opens and clicks in total and per step |
 
 ### Messaging
 | Tool | Description |
@@ -91,6 +97,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_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
 | Tool | Description |

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}"),
+        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."),
         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"),
+        actions: z.any().optional().describe("Updated actions graph (same shape as create; e.g. enroll_in_sequence {sequenceId, enrollAction: 'add' | 'remove'})"),
         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/messaging.js

@@ -88,6 +88,24 @@ export function registerMessagingTools(server, client) {
         const result = await client.get(`/api/v1/messages?${params}`);
         return formatResult(result);
     });
+    server.tool("conduyt_log_message", "Record a message on a contact's timeline (POST /messages): an inbound text or email that arrived through another system, or an outbound email (sent through the workspace's verified domain). Outbound SMS is refused here unless status is 'draft': use conduyt_send_sms. An inbound SMS whose body is STOP (or START) with a fromNumber records that number's opt-out (or opt-in), stops the contact's sequences and drips on STOP, exactly like a text that came in through a provider; the 201 then carries smsConsent {keyword: stop | start, fromNumber, applied, reason?}: applied true when the number's consent changed, else reason number_not_on_contact (the number is not the contact's primary or secondary number: only the message is stored) or number_not_canonicalizable (the number could not be read). Requires communications:create.", {
+        contactId: z.string().uuid().describe("Contact UUID"),
+        channel: z.enum(["sms", "email"]).describe("Channel"),
+        direction: z.enum(["inbound", "outbound"]).describe("inbound = from the contact, outbound = to the contact"),
+        body: z.string().describe("Message body (max 100KB)"),
+        subject: z.string().max(500).optional().describe("Subject (email)"),
+        fromNumber: z.string().max(30).optional().describe("SMS: the sending number (for an inbound STOP/START, the contact's number whose consent changes)"),
+        toNumber: z.string().max(30).optional().describe("SMS: the receiving number"),
+        fromEmail: z.string().email().optional().describe("Email: the sender address"),
+        toEmail: z.string().email().optional().describe("Email: the recipient address (outbound: must be the contact's address)"),
+        provider: z.string().optional().describe("The system the message came through"),
+        providerId: z.string().optional().describe("That system's id for the message"),
+        status: z.string().optional().describe("Message status, e.g. 'draft'"),
+        scheduledAt: z.string().optional().describe("ISO date-time to send an outbound email later (needs a verified sending domain)"),
+    }, async (params) => {
+        const result = await client.post("/api/v1/messages", params);
+        return formatResult(result);
+    });
     server.tool("conduyt_sms_delivery_report", "SMS provider delivery-outcome report for external-workflow SMS drips: per-automation entered vs delivered / rejected (invalid, litigator, DNC) / provider-error / workflow dead-end, plus a send-attempt 'why rejected' reason breakdown (line_type = 'not mobile' often WRONGLY rejected; landline_skipped / no_phone_skipped = Conduyt's own recorded skips). Use to answer 'what did the SMS provider do with our drips?'", {
         from: z.string().optional().describe("ISO start (omit both for the last 180 days; spans clamp to 180d)"),
         to: z.string().optional().describe("ISO end"),

package/dist/tools/sequences.js

@@ -1,14 +1,48 @@
 import { z } from "zod";
 import { formatResult } from "../client.js";
+/**
+ * Sequences (one model for Email and SMS since 2026-09-30): steps send saved templates of the sequence's channel a
+ * number of days apart inside a send window; a run stops on a reply, a booked meeting, an opt-out, a closed deal or a
+ * removal. Provider drip timetables (BDA) are a different thing: see the drip-campaign tools.
+ */
+const settingsFields = {
+    senderUserId: z.string().uuid().nullable().optional().describe("The team member the messages are from (must be an active member): email from their on-domain address, SMS from their assigned line. null = the workspace default"),
+    autoUnenrollOnReply: z.boolean().optional().describe("Stop the contact's run when they reply to any message of the sequence (default true)"),
+    autoUnenrollOnMeeting: z.boolean().optional().describe("Stop the run when a meeting is booked through any Conduyt calendar (default true)"),
+    autoUnenrollOnUnsubscribe: z.boolean().optional().describe("Stop the run when the contact opts out: unsubscribe, or STOP for SMS (default true)"),
+    autoUnenrollOnBounce: z.boolean().optional().describe("Email only. Stop the run on a hard bounce; a soft bounce waits and retries (default true)"),
+    autoUnenrollOnDealClosed: z.boolean().optional().describe("Stop the contact's run when any of their deals closes, won or lost, on any stage of a closed kind (default true)"),
+    allowAutomationEnroll: z.boolean().optional().describe("Let the automation action enroll_in_sequence put contacts in (default true)"),
+    allowReenroll: z.boolean().optional().describe("Let a contact go through it again once their earlier run ENDED (default false). A live or paused run is never restarted"),
+    weekdaysOnly: z.boolean().optional().describe("Send Monday to Friday only, in the contact's time zone (default true)"),
+    sendStartHour: z.number().int().min(0).max(23).optional().describe("First hour of the send window, local (default 9)"),
+    sendEndHour: z.number().int().min(1).max(24).optional().describe("End of the send window, exclusive (default 17). A step due outside the window waits for the next opening"),
+};
+const uuid = (what) => z.string().uuid().describe(what);
+/** how a run ended (enrollment endedReason), and the run statuses, as GET /emails/sequences/{id}/enrollments answers them */
+const RUN_READING = "Each run carries status (active | paused | completed | failed | cancelled | unsubscribed) and endedReason (completed | replied | meeting | opted_out | bounced | deal_closed | removed | failed | no_phone; null while the run is live). A paused run with no endedReason is LIVE (the sequence is Off or archived; it resumes when turned On); a failed run with no endedReason is ALSO LIVE (an ambiguous send outcome — a timeout, an unknown provider answer — that a late provider acceptance can still revive in place), while failed WITH endedReason \"failed\" is TERMINAL (a definitive worker or repair failure, no revival). no_phone is SMS-only: the run ended because the contact had no usable phone. A paused, failed or cancelled run with an endedReason has ended.";
+const stepSchema = z.object({
+    templateId: z.string().uuid().describe("An active template of the sequence's channel (Email Templates or SMS Templates)"),
+    waitDays: z.number().int().min(0).optional().describe("Days after the previous step (the first step sends at enrollment)"),
+});
 export function registerSequenceTools(server, client) {
-    server.tool("conduyt_list_sequences", "List email sequences (drip campaigns). Returns name, step count, enrollment stats, and active status.", {
-        is_active: z.boolean().optional().describe("Filter by active/inactive status"),
+    server.tool("conduyt_list_sequences", "List sequences (Email and SMS), newest first. Each carries type (email | sms), isActive (On/Off), steps, senderUserId and sender, the stop rules (autoUnenrollOnReply, autoUnenrollOnMeeting, autoUnenrollOnUnsubscribe, autoUnenrollOnBounce, autoUnenrollOnDealClosed), allowAutomationEnroll, allowReenroll, weekdaysOnly, sendStartHour, sendEndHour, archivedAt, and the people in it now (_count.enrollments). Archived sequences are left out unless archived=true. An API key sees only the channel(s) it is scoped to (a type filter outside its scope is a 403).", {
+        type: z.enum(["email", "sms"]).optional().describe("Only sequences of this channel"),
+        is_active: z.boolean().optional().describe("Only sequences that are On (true) or Off (false)"),
+        archived: z.boolean().optional().describe("true lists archived sequences only"),
+        view: z.enum(["summary"]).optional().describe("summary = a light row per sequence (id, name, type, isActive, createdAt, updatedAt, enrolledCount, description cut to 300 characters, stepCount), no step JSON"),
         page: z.number().optional().describe("Page number (default 1)"),
         per_page: z.number().optional().describe("Results per page (default 50, max 200)"),
-    }, async ({ is_active, page, per_page }) => {
+    }, async ({ type, is_active, archived, view, page, per_page }) => {
         const params = new URLSearchParams();
+        if (type)
+            params.set("type", type);
         if (is_active !== undefined)
             params.set("is_active", String(is_active));
+        if (archived !== undefined)
+            params.set("archived", String(archived));
+        if (view)
+            params.set("view", view);
         if (page)
             params.set("page", String(page));
         if (per_page)
@@ -16,38 +50,102 @@ export function registerSequenceTools(server, client) {
         const result = await client.get(`/api/v1/emails/sequences?${params}`);
         return formatResult(result);
     });
-    server.tool("conduyt_get_sequence", "Get a single email sequence with full details — steps, enrollment stats, and configuration.", {
-        id: z.string().describe("Sequence UUID"),
+    server.tool("conduyt_get_sequence", "Get a single sequence with full details: type, isActive, steps (template per step, wait in days), senderUserId and sender, send window (weekdaysOnly, sendStartHour, sendEndHour), stop rules, allowAutomationEnroll, allowReenroll, archivedAt, the people in it now (_count.enrollments) and enrollmentStats (people per run status).", {
+        id: uuid("Sequence UUID"),
     }, async ({ id }) => {
         const result = await client.get(`/api/v1/emails/sequences/${id}`);
         return formatResult(result);
     });
-    server.tool("conduyt_create_sequence", "Create a new email sequence with steps. Each step has a delay and email content.", {
+    server.tool("conduyt_create_sequence", "Create an Email or SMS sequence from saved templates. Every step names a template of the sequence's channel and a wait in days; the type cannot change afterwards. Created Off unless isActive is true (turning it On checks the steps; 422 lists what is wrong). Runs stop on a reply, a booked meeting, an opt-out (STOP for SMS), a closed deal (autoUnenrollOnDealClosed) or a removal.", {
         name: z.string().describe("Sequence name"),
         description: z.string().optional().describe("Sequence description"),
-        isActive: z.boolean().optional().describe("Whether the sequence is active (default true)"),
-        steps: z.array(z.object({
-            delay: z.number().optional().describe("Delay in seconds before sending this step"),
-            body: z.string().optional().describe("Plain text email body"),
-            bodyHtml: z.string().optional().describe("HTML email body"),
-            templateId: z.string().optional().describe("Email template UUID to use instead of inline body"),
-        })).optional().describe("Sequence steps in order"),
+        type: z.enum(["email", "sms"]).optional().describe("The channel (default email). Immutable after creation"),
+        isActive: z.boolean().optional().describe("On (true) or Off (false, the default)"),
+        steps: z.array(stepSchema).min(1).describe("Steps in order"),
+        ...settingsFields,
     }, async (params) => {
         const result = await client.post("/api/v1/emails/sequences", params);
         return formatResult(result);
     });
-    server.tool("conduyt_enroll_in_sequence", "Enroll one or more contacts into an email sequence. Skips contacts already enrolled.", {
-        sequenceId: z.string().describe("Sequence UUID"),
-        contactIds: z.array(z.string()).describe("Array of contact UUIDs to enroll"),
+    server.tool("conduyt_update_sequence", "Update a sequence: name, steps, sender, send window, stop rules, enrollment switches; turn it On or Off (isActive); archive it (archived: true turns it Off and hides it) or restore it (archived: false; it stays Off until turned On). The type cannot change (400 when sent). While people are in it, the steps they already received cannot be changed, removed or reordered (409 sequence_steps_in_use); later steps change and new ones append.", {
+        id: uuid("Sequence UUID"),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        isActive: z.boolean().optional().describe("On (true) or Off (false). Off keeps every run where it is; the steps resume when turned On"),
+        archived: z.boolean().optional().describe("true = Off and hidden from lists; false = restored"),
+        steps: z.array(stepSchema).min(1).optional().describe("The whole step list, in order (replaces the current steps)"),
+        ...settingsFields,
+    }, async ({ id, ...updates }) => {
+        const result = await client.patch(`/api/v1/emails/sequences/${id}`, updates);
+        return formatResult(result);
+    });
+    server.tool("conduyt_list_sequence_senders", "Who can be a sequence's sender, for one channel: every active team member who accepted their invite. channel sms lists each member's assigned line (did, null when none: an SMS sequence needs a sender with a line); channel email lists each member's address. Use an id here as senderUserId.", {
+        channel: z.enum(["email", "sms"]).describe("The sequence's channel"),
+    }, async ({ channel }) => {
+        const result = await client.get(`/api/v1/emails/sequences/senders?channel=${channel}`);
+        return formatResult(result);
+    });
+    server.tool("conduyt_preflight_sequence_enrollment", "Check contacts BEFORE enrolling them: who is eligible and who would be skipped, with the reason (no email or phone for the channel, opted out, already in this sequence, already went through it, a bounced address, not in your scope). Returns total, eligible, skipped, errors (blockers: the sequence is Off or archived, a template is missing, the sending domain is not verified; any blocker makes nobody eligible), warnings, missingTemplates, domainReady and contacts [{contactId, eligible, reasons}]. Nothing is written.", {
+        sequenceId: uuid("Sequence UUID"),
+        contactIds: z.array(z.string().uuid()).min(1).max(500).describe("Contact UUIDs to check (up to 500)"),
+    }, async ({ sequenceId, contactIds }) => {
+        const result = await client.post(`/api/v1/emails/sequences/${sequenceId}/preflight`, { contactIds });
+        return formatResult(result);
+    });
+    server.tool("conduyt_pick_sequence_list", "Who of a saved list (a Smart View or a Smart List) goes into a sequence next: the server walks the list in a stable order, leaves out the contacts already in the sequence, judges the rest with the enrollment check, and returns up to `limit` eligible contacts plus a cursor to continue. Returns listTotal, scanned, alreadyIn, contacts [{id, firstName, lastName, email, phone}], ineligible [{contactId, reasons}], blockers (Off, archived, a missing template, an unverified domain: no contacts are returned while any stands), cursor and exhausted. Enroll the returned ids with conduyt_enroll_in_sequence, then call again with the cursor until exhausted. Needs the contacts and communications scopes; Smart Lists are admin-only. Nothing is written.", {
+        sequenceId: uuid("Sequence UUID"),
+        smartViewId: z.string().uuid().optional().describe("The Smart View to pick from (one of smartViewId / smartListId)"),
+        smartListId: z.string().uuid().optional().describe("The Smart List to pick from"),
+        limit: z.number().int().min(1).max(500).optional().describe("Eligible contacts to return (default 500)"),
+        cursor: z.string().optional().describe("Where to continue, from the previous call's `cursor`"),
+    }, async ({ sequenceId, smartViewId, smartListId, limit, cursor }) => {
+        const result = await client.post(`/api/v1/emails/sequences/${sequenceId}/pick-from-list`, { smartViewId, smartListId, limit, cursor });
+        return formatResult(result);
+    });
+    server.tool("conduyt_enroll_in_sequence", "Enroll one or more contacts into a sequence (up to 500 per call; the sequence must be On and not archived, else 404). Skips contacts with no address for the channel, opted out, or already in it; with allowReenroll on, a contact whose earlier run ENDED starts over (a live or paused run never restarts). Returns enrolled, skipped, duplicates, total, skippedDetails [{contactId, reasons}], and outOfScope / staleAfterPreflight when they apply. Check first with conduyt_preflight_sequence_enrollment.", {
+        sequenceId: uuid("Sequence UUID"),
+        contactIds: z.array(z.string().uuid()).min(1).max(500).describe("Array of contact UUIDs to enroll"),
     }, async ({ sequenceId, contactIds }) => {
         const result = await client.post(`/api/v1/emails/sequences/${sequenceId}/enroll`, { contactIds });
         return formatResult(result);
     });
-    server.tool("conduyt_unenroll_from_sequence", "Remove a contact from an email sequence. Pauses their enrollment.", {
-        sequenceId: z.string().describe("Sequence UUID"),
-        contactId: z.string().describe("Contact UUID to unenroll"),
+    server.tool("conduyt_unenroll_from_sequence", "Remove a contact from a sequence (one contact per call). Their live, paused or failed run ends: status cancelled, endedReason removed, no more steps; it can start over later only if the sequence allows re-enrollment. Returns contactId, unenrolled (false when the run had already ended) and currentStatus.", {
+        sequenceId: uuid("Sequence UUID"),
+        contactId: z.string().uuid().describe("Contact UUID to unenroll"),
     }, async ({ sequenceId, contactId }) => {
         const result = await client.post(`/api/v1/emails/sequences/${sequenceId}/unenroll`, { contactId });
         return formatResult(result);
     });
+    server.tool("conduyt_list_sequence_enrollments", `List the people in a sequence, newest run first: each run's contact, currentStep, nextSendAt, enrolledAt, completedAt, lastError and engagement (sent, opened, clicked). ${RUN_READING}`, {
+        sequenceId: uuid("Sequence UUID"),
+        status: z.enum(["active", "paused", "completed", "failed", "cancelled", "unsubscribed"]).optional().describe("Only runs with this status. Refused together with all_active=true — see all_active"),
+        all_active: z.boolean().optional().describe("true = EVERY live run (active, paused with no endedReason, failed with no endedReason) in one answer, no paging and no engagement; refused (422 too_many_live_runs) past 5,000. Pass it ALONE: status, page and per_page are refused together with all_active=true, because a status filter or pagination would silently cut the live set a rollback page relies on being complete"),
+        page: z.number().optional().describe("Page number (default 1). Refused together with all_active=true — see all_active"),
+        per_page: z.number().optional().describe("Results per page (default 50, max 200). Refused together with all_active=true — see all_active"),
+    }, async ({ sequenceId, status, all_active, page, per_page }) => {
+        // (round 2 Codex finding, high) all_active=true promises the COMPLETE live set. Letting status or pagination
+        // ride along would let the live route intersect them and silently return a subset while the caller believes
+        // it holds every live run (the risk: a rollback/bulk-unenroll agent leaves contacts mid-sequence). Refuse
+        // locally, before any request, rather than letting the subset through.
+        if (all_active && (status !== undefined || page !== undefined || per_page !== undefined)) {
+            throw new Error("all_active=true already returns every live run in one answer — pass it alone. status, page and per_page are refused together with all_active=true because they would cut the set instead of returning the complete one.");
+        }
+        const params = new URLSearchParams();
+        if (status)
+            params.set("status", status);
+        if (all_active !== undefined)
+            params.set("all_active", String(all_active));
+        if (page)
+            params.set("page", String(page));
+        if (per_page)
+            params.set("per_page", String(per_page));
+        const result = await client.get(`/api/v1/emails/sequences/${sequenceId}/enrollments?${params}`);
+        return formatResult(result);
+    });
+    server.tool("conduyt_get_sequence_stats", "Performance of a sequence: totals {enrolled (runs started, all time), contacts (people in it now), sent, opened, clicked, loggedSends, openRate, clickRate}, perStep [{step, sent, opened, clicked, openRate, clickRate}] for the current steps, and removedSteps for sends from steps no longer in it. A send counts once the provider took it (sent, delivered, bounced, complained).", {
+        sequenceId: uuid("Sequence UUID"),
+    }, async ({ sequenceId }) => {
+        const result = await client.get(`/api/v1/emails/sequences/${sequenceId}/stats`);
+        return formatResult(result);
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.71.1",
+  "version": "4.72.1",
   "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,11 +1,11 @@
 {
-  "generatedAt": "2026-09-30T16:40:04.197Z",
-  "toolCount": 292,
-  "totalEndpoints": 1031,
+  "generatedAt": "2026-10-02T16:12:21.781Z",
+  "toolCount": 299,
+  "totalEndpoints": 1036,
   "counts": {
-    "covered": 266,
-    "excluded": 311,
-    "planned": 454,
+    "covered": 273,
+    "excluded": 313,
+    "planned": 450,
     "uncategorized": 0
   },
   "matrix": {
@@ -1801,6 +1801,14 @@
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
     },
+    "GET /api/v1/cron/process-sms-sequences": {
+      "status": "excluded",
+      "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
+    },
+    "POST /api/v1/cron/process-sms-sequences": {
+      "status": "excluded",
+      "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
+    },
     "GET /api/v1/cron/process-subscriber-deals": {
       "status": "excluded",
       "reason": "CRON_SECRET-gated infrastructure jobs; never key-callable"
@@ -2652,8 +2660,10 @@
       ]
     },
     "PATCH /api/v1/emails/sequences/:id": {
-      "status": "planned",
-      "reason": "email template/sequence management"
+      "status": "covered",
+      "tools": [
+        "conduyt_update_sequence"
+      ]
     },
     "POST /api/v1/emails/sequences/:id/enroll": {
       "status": "covered",
@@ -2662,16 +2672,28 @@
       ]
     },
     "GET /api/v1/emails/sequences/:id/enrollments": {
-      "status": "planned",
-      "reason": "email template/sequence management"
+      "status": "covered",
+      "tools": [
+        "conduyt_list_sequence_enrollments"
+      ]
+    },
+    "POST /api/v1/emails/sequences/:id/pick-from-list": {
+      "status": "covered",
+      "tools": [
+        "conduyt_pick_sequence_list"
+      ]
     },
     "POST /api/v1/emails/sequences/:id/preflight": {
-      "status": "planned",
-      "reason": "email template/sequence management"
+      "status": "covered",
+      "tools": [
+        "conduyt_preflight_sequence_enrollment"
+      ]
     },
     "GET /api/v1/emails/sequences/:id/stats": {
-      "status": "planned",
-      "reason": "email template/sequence management"
+      "status": "covered",
+      "tools": [
+        "conduyt_get_sequence_stats"
+      ]
     },
     "POST /api/v1/emails/sequences/:id/unenroll": {
       "status": "covered",
@@ -2679,6 +2701,12 @@
         "conduyt_unenroll_from_sequence"
       ]
     },
+    "GET /api/v1/emails/sequences/senders": {
+      "status": "covered",
+      "tools": [
+        "conduyt_list_sequence_senders"
+      ]
+    },
     "GET /api/v1/emails/templates": {
       "status": "covered",
       "tools": [
@@ -3040,8 +3068,10 @@
       ]
     },
     "POST /api/v1/messages": {
-      "status": "planned",
-      "reason": "message surfaces beyond send tools"
+      "status": "covered",
+      "tools": [
+        "conduyt_log_message"
+      ]
     },
     "GET /api/v1/messages/:id/media/:mediaIndex": {
       "status": "planned",
@@ -4164,6 +4194,10 @@
       "status": "planned",
       "reason": "SMS surfaces beyond send tools"
     },
+    "GET /api/v1/sms-providers/options": {
+      "status": "planned",
+      "reason": "SMS surfaces beyond send tools"
+    },
     "GET /api/v1/sms/send-logs": {
       "status": "planned",
       "reason": "SMS surfaces beyond send tools"