conduyt-mcp 4.66.0 → 4.68.0

package/dist/tools/advanced-filter-compilability.d.ts

@@ -0,0 +1,6 @@
+/** the exact compile verdict of the app for one rule: true when advancedRuleToWhere would return a condition */
+export declare function advancedRuleCompiles(rule: {
+    field: string;
+    operator: string;
+    value?: unknown;
+}): boolean;

package/dist/tools/advanced-filter-compilability.js

@@ -0,0 +1,127 @@
+/**
+ * (Codex mcp/cli r6 h1) DOES THIS RULE COMPILE? — the null-returning paths of advancedRuleToWhere / ruleToWhere /
+ * customFieldRuleToWhere / masterStatusRuleToWhere in lib/smart-view-filters.ts, as ONE pure predicate with no Prisma and no
+ * imports, so the MCP server and the CLI can carry it VERBATIM and refuse exactly what the app's validator refuses (the app's
+ * validator runs the real compiler; lib/advanced-filter-compilability.test.ts proves this predicate agrees with it over an
+ * adversarial value matrix for every field, operator and custom-field operator). Keep in sync with the compiler.
+ */
+const CF_FIELD_PREFIX = "cf:";
+const CF_OPERATORS = new Set(["equals", "not_equals", "contains", "is_any_of", "is", "is_not", "num_equals", "num_not_equals", "gt", "gte", "lt", "lte", "is_true", "is_false", "has_any_of", "has_all_of", "has_none_of"]);
+const SCALAR_DATE_FIELDS = new Set(["lastContactedAt", "lastActionAt", "lastContactAttemptAt", "createdAt", "updatedAt"]);
+const LIST_FIELDS = new Set(["tags", "pipeline", "pipelineStage", "dealStatus", "email", "phone", "source", "assignedTo"]);
+const STRING_FIELDS = new Set(["city", "state", "jobTitle"]);
+function cfKeyOf(field) {
+    if (!field.startsWith(CF_FIELD_PREFIX))
+        return null;
+    const key = field.slice(CF_FIELD_PREFIX.length).trim();
+    return key.length > 0 ? key : null;
+}
+function isValidIsoDate(value) {
+    const ts = Date.parse(value);
+    return !isNaN(ts) && new Date(ts).toISOString() !== "Invalid Date";
+}
+const has = (set, op) => set.includes(op);
+/** the exact compile verdict of the app for one rule: true when advancedRuleToWhere would return a condition */
+export function advancedRuleCompiles(rule) {
+    const { field, operator: rawOp, value } = rule;
+    const operator = rawOp === "is" ? "equals" : rawOp === "is_not" ? "not_equals" : rawOp;
+    const strValue = Array.isArray(value) ? value.join(",") : value;
+    // String(undefined) is "undefined" in the compiler's own coercions: an absent value there is a one-element list, verbatim
+    const listOf = (v) => (Array.isArray(v) ? v : String(v).split(",")).map((x) => String(x).trim()).filter(Boolean);
+    const cfKey = cfKeyOf(field);
+    if (cfKey) {
+        const op = CF_OPERATORS.has(rawOp) ? rawOp : operator;
+        switch (op) {
+            case "equals":
+            case "is":
+            case "not_equals":
+            case "is_not":
+            case "contains":
+            case "is_true":
+            case "is_false": return true;
+            case "is_any_of": return (Array.isArray(value) ? value : String(value).split(",").map((v) => v.trim()).filter(Boolean)).length > 0;
+            case "num_equals":
+            case "num_not_equals":
+            case "gt":
+            case "gte":
+            case "lt":
+            case "lte": {
+                const s = strValue ?? "";
+                return s.trim() !== "" && Number.isFinite(Number(s));
+            }
+            case "has_any_of":
+            case "has_all_of":
+            case "has_none_of": return listOf(value).length > 0;
+            default: return false;
+        }
+    }
+    if (field === "masterStatus") {
+        const list = (Array.isArray(value) ? value : String(value ?? "").split(",")).map((v) => String(v).trim().toLowerCase()).filter(Boolean);
+        if (list.length === 0)
+            return false;
+        if (rawOp === "is_any_of" || rawOp === "is_none_of")
+            return true;
+        return operator === "equals" || operator === "not_equals";
+    }
+    if (rawOp === "is_any_of") {
+        const values = Array.isArray(value) ? value : String(value ?? "").split(",").map((v) => v.trim()).filter(Boolean);
+        return values.length > 0 && LIST_FIELDS.has(field);
+    }
+    if (field === "company")
+        return has(["is_empty", "is_not_empty", "equals", "not_equals", "contains"], operator);
+    // (Codex pool r28 h1) a name-bearing tag rule needs at least one name (lib/tag-rule-names.ts: an array is one name per
+    // element, a scalar splits on commas; blanks dropped)
+    if (field === "tags" && has(["contains", "not_contains", "equals", "not_equals"], operator)) {
+        const names = Array.isArray(value) ? value.filter((x) => typeof x === "string").map((x) => x.trim()).filter(Boolean) : typeof value === "string" ? value.split(",").map((x) => x.trim()).filter(Boolean) : [];
+        return names.length > 0;
+    }
+    // ruleToWhere on the flattened value
+    const v = strValue ?? "";
+    // a duration is parsed with String.prototype.match: an ABSENT value throws inside the compiler (dropped), any string parses
+    const hasString = typeof strValue === "string";
+    if (SCALAR_DATE_FIELDS.has(field)) {
+        if (operator === "is_empty" || operator === "is_not_empty")
+            return true;
+        if (operator === "within" || operator === "not_within")
+            return hasString;
+        if (operator === "before" || operator === "after")
+            return isValidIsoDate(v);
+        return false;
+    }
+    if (field === "lastEmailAt" || field === "lastSmsAt") {
+        if (operator === "is_empty" || operator === "is_not_empty")
+            return true;
+        if (operator === "within" || operator === "not_within")
+            return hasString;
+        if (operator === "before" || operator === "after")
+            return isValidIsoDate(v);
+        return false;
+    }
+    if (field === "lastCallAt")
+        return operator === "is_empty" || operator === "is_not_empty" || (hasString && (operator === "within" || operator === "not_within"));
+    if (field === "callAttempts")
+        return true; // an unsupported boundary compiles to the impossible filter (the validator gates the value)
+    if (field === "nextAppointmentAt")
+        return operator === "is_empty" || operator === "is_not_empty" || (hasString && (operator === "within" || operator === "not_within"));
+    if (field === "appointmentStatus")
+        return has(["equals", "not_equals"], operator);
+    if (STRING_FIELDS.has(field))
+        return has(["is_empty", "is_not_empty", "equals", "not_equals", "contains"], operator);
+    if (field === "country")
+        return has(["equals", "not_equals"], operator);
+    if (field === "optedOutSms" || field === "optedOutEmail")
+        return operator === "equals";
+    if (field === "leadScore")
+        return v.trim() !== "" && Number.isFinite(Number(v.trim())) && has(["gt", "lt", "gte", "lte", "equals"], operator); // (Codex pool r28 m1) the whole value
+    if (field === "email" || field === "phone")
+        return has(["is_empty", "is_not_empty", "contains", "equals", "not_equals"], operator);
+    if (field === "source")
+        return has(["equals", "not_equals", "contains", "is_empty", "is_not_empty"], operator);
+    if (field === "assignedTo")
+        return has(["equals", "not_equals", "is_empty", "is_not_empty"], operator);
+    if (field === "tags")
+        return has(["is_empty", "is_not_empty"], operator);
+    if (field === "pipeline" || field === "pipelineStage" || field === "dealStatus")
+        return has(["equals", "not_equals", "is_empty", "is_not_empty"], operator);
+    return false;
+}

package/dist/tools/advanced-filter-rules.d.ts

@@ -0,0 +1,37 @@
+/**
+ * PORTED VERBATIM from conduyt-app lib/smart-view-filters.ts @ slice B r28 (bfba9b0ef + the non-string array element refusal; the app's validator additionally compiles every rule — see validateAdvancedFiltersEffective below) — validateAdvancedFilters, its tables and its
+ * value rules — so a call this surface accepts is never a predictable 400 from the API (Codex mcp r2 m1 / cli r2 m1).
+ * Keep in sync with the app: when validateAdvancedFilters, VALID_FIELDS, VALID_OPERATORS, ADVANCED_OPERATORS,
+ * CF_OPERATORS, VALUELESS_OPERATORS, DATE_FILTER_FIELDS or isSupportedCallAttemptsFilter change there, re-port here.
+ */
+export declare const CF_FIELD_PREFIX = "cf:";
+export declare const MAX_FILTER_GROUPS = 10;
+export declare const MAX_RULES_PER_GROUP = 20;
+export declare const VALID_FIELDS: Set<string>;
+export declare const ADVANCED_OPERATORS: Record<string, Set<string>>;
+export declare const CF_OPERATORS: Set<string>;
+export declare function customFieldKey(field: string): string | null;
+export type FilterGroupPayload = {
+    conjunction: "AND" | "OR";
+    rules: Array<{
+        field: string;
+        operator: string;
+        value?: string | string[];
+    }>;
+};
+/** the API's validateAdvancedFilters, verbatim: the same verdict and the same message for the same payload */
+export declare function validateAdvancedFilters(payload: unknown): {
+    valid: true;
+    groups: FilterGroupPayload[];
+} | {
+    valid: false;
+    error: string;
+};
+/** validateAdvancedFilters (the port) PLUS the compile verdict per rule: the same answer the API gives a write */
+export declare function validateAdvancedFiltersEffective(payload: unknown): {
+    valid: true;
+    groups: FilterGroupPayload[];
+} | {
+    valid: false;
+    error: string;
+};

package/dist/tools/advanced-filter-rules.js

@@ -0,0 +1,207 @@
+/**
+ * PORTED VERBATIM from conduyt-app lib/smart-view-filters.ts @ slice B r28 (bfba9b0ef + the non-string array element refusal; the app's validator additionally compiles every rule — see validateAdvancedFiltersEffective below) — validateAdvancedFilters, its tables and its
+ * value rules — so a call this surface accepts is never a predictable 400 from the API (Codex mcp r2 m1 / cli r2 m1).
+ * Keep in sync with the app: when validateAdvancedFilters, VALID_FIELDS, VALID_OPERATORS, ADVANCED_OPERATORS,
+ * CF_OPERATORS, VALUELESS_OPERATORS, DATE_FILTER_FIELDS or isSupportedCallAttemptsFilter change there, re-port here.
+ */
+export const CF_FIELD_PREFIX = "cf:";
+export const MAX_FILTER_GROUPS = 10;
+export const MAX_RULES_PER_GROUP = 20;
+export const VALID_FIELDS = new Set([
+    "lastContactedAt", "lastActionAt", "lastContactAttemptAt", "createdAt", "updatedAt", "lastEmailAt", "lastSmsAt",
+    "lastCallAt", "callAttempts", "nextAppointmentAt", "appointmentStatus",
+    "city", "state", "country", "jobTitle", "optedOutSms", "optedOutEmail",
+    "leadScore", "email", "phone", "source", "assignedTo", "tags",
+    "pipeline", "pipelineStage", "dealStatus", "company",
+    "masterStatus",
+]);
+const VALID_OPERATORS = {
+    lastContactedAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    lastActionAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    lastContactAttemptAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    createdAt: new Set(["within", "not_within", "before", "after"]),
+    updatedAt: new Set(["within", "not_within", "before", "after"]),
+    lastEmailAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    lastSmsAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    lastCallAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    callAttempts: new Set(["gt", "lt", "gte", "lte", "equals"]),
+    nextAppointmentAt: new Set(["within", "not_within", "is_empty", "is_not_empty"]),
+    appointmentStatus: new Set(["equals", "not_equals"]),
+    leadScore: new Set(["gt", "lt", "gte", "lte", "equals"]),
+    email: new Set(["is_empty", "is_not_empty", "contains"]),
+    phone: new Set(["is_empty", "is_not_empty", "contains"]),
+    source: new Set(["equals", "not_equals", "contains"]),
+    assignedTo: new Set(["equals", "not_equals", "is_empty"]),
+    tags: new Set(["contains", "not_contains", "is_empty", "is_not_empty"]),
+    pipeline: new Set(["equals", "not_equals", "is_empty", "is_not_empty"]),
+    pipelineStage: new Set(["equals", "not_equals", "is_empty", "is_not_empty"]),
+    dealStatus: new Set(["equals", "not_equals", "is_empty", "is_not_empty"]),
+    masterStatus: new Set(["equals", "not_equals", "is_any_of", "is_none_of"]),
+    city: new Set(["equals", "not_equals", "contains", "is_empty", "is_not_empty"]),
+    state: new Set(["equals", "not_equals", "contains", "is_empty", "is_not_empty"]),
+    country: new Set(["equals", "not_equals"]),
+    jobTitle: new Set(["equals", "not_equals", "contains", "is_empty", "is_not_empty"]),
+    optedOutSms: new Set(["equals"]),
+    optedOutEmail: new Set(["equals"]),
+    company: new Set(["equals", "not_equals", "contains", "is_empty", "is_not_empty"]),
+};
+export const ADVANCED_OPERATORS = {
+    lastContactedAt: new Set([...VALID_OPERATORS.lastContactedAt, "before", "after"]),
+    lastActionAt: new Set([...VALID_OPERATORS.lastActionAt, "before", "after"]),
+    lastContactAttemptAt: new Set([...VALID_OPERATORS.lastContactAttemptAt, "before", "after"]),
+    createdAt: new Set([...VALID_OPERATORS.createdAt, "is_empty", "is_not_empty"]),
+    updatedAt: new Set([...VALID_OPERATORS.updatedAt, "is_empty", "is_not_empty"]),
+    lastEmailAt: new Set([...VALID_OPERATORS.lastEmailAt, "is_not_empty", "before", "after"]),
+    lastSmsAt: new Set([...VALID_OPERATORS.lastSmsAt, "is_not_empty", "before", "after"]),
+    lastCallAt: new Set([...VALID_OPERATORS.lastCallAt, "before", "after"]),
+    callAttempts: new Set([...VALID_OPERATORS.callAttempts]),
+    nextAppointmentAt: new Set([...VALID_OPERATORS.nextAppointmentAt]),
+    appointmentStatus: new Set([...VALID_OPERATORS.appointmentStatus, "is", "is_not", "is_any_of"]),
+    leadScore: new Set([...VALID_OPERATORS.leadScore]),
+    email: new Set([...VALID_OPERATORS.email, "is", "is_not", "is_any_of"]),
+    phone: new Set([...VALID_OPERATORS.phone, "is", "is_not", "is_any_of"]),
+    source: new Set([...VALID_OPERATORS.source, "is", "is_not", "is_empty", "is_not_empty", "is_any_of"]),
+    assignedTo: new Set([...VALID_OPERATORS.assignedTo, "is", "is_not", "is_not_empty"]),
+    tags: new Set([...VALID_OPERATORS.tags, "is", "is_not", "is_any_of"]),
+    pipeline: new Set([...VALID_OPERATORS.pipeline, "is", "is_not", "is_any_of"]),
+    pipelineStage: new Set([...VALID_OPERATORS.pipelineStage, "is", "is_not", "is_empty", "is_not_empty", "is_any_of"]),
+    dealStatus: new Set([...VALID_OPERATORS.dealStatus, "is", "is_not", "is_empty", "is_not_empty", "is_any_of"]),
+    masterStatus: new Set([...VALID_OPERATORS.masterStatus, "is", "is_not"]),
+    city: new Set([...VALID_OPERATORS.city, "is", "is_not", "is_any_of"]),
+    state: new Set([...VALID_OPERATORS.state, "is", "is_not", "is_any_of"]),
+    country: new Set([...VALID_OPERATORS.country, "is", "is_not", "is_any_of"]),
+    jobTitle: new Set([...VALID_OPERATORS.jobTitle, "is", "is_not", "is_any_of"]),
+    optedOutSms: new Set([...VALID_OPERATORS.optedOutSms]),
+    optedOutEmail: new Set([...VALID_OPERATORS.optedOutEmail]),
+    company: new Set(["is", "is_not", "contains", "is_empty", "is_not_empty"]),
+};
+export const CF_OPERATORS = new Set([
+    "equals", "not_equals", "contains", "is_any_of", "is", "is_not",
+    "num_equals", "num_not_equals", "gt", "gte", "lt", "lte", "is_true", "is_false",
+    "has_any_of", "has_all_of", "has_none_of",
+]);
+const VALUELESS_OPERATORS = new Set(["is_empty", "is_not_empty", "is_true", "is_false"]);
+const DATE_FILTER_FIELDS = new Set([
+    "createdAt", "updatedAt", "lastContactedAt", "lastActionAt", "lastContactAttemptAt", "lastEmailAt", "lastSmsAt", "lastCallAt", "nextAppointmentAt",
+]);
+export function customFieldKey(field) {
+    if (!field.startsWith(CF_FIELD_PREFIX))
+        return null;
+    const key = field.slice(CF_FIELD_PREFIX.length).trim();
+    return key.length > 0 ? key : null;
+}
+function normalizeOperator(_field, operator) {
+    if (operator === "is")
+        return "equals";
+    if (operator === "is_not")
+        return "not_equals";
+    return operator;
+}
+function isSupportedCallAttemptsFilter(operator, value) {
+    const num = Number(value);
+    if (!Number.isInteger(num) || num < 0)
+        return false;
+    return ((operator === "equals" && num === 0) ||
+        (operator === "gt" && num === 0) ||
+        (operator === "gte" && num === 1) ||
+        (operator === "lt" && num === 1) ||
+        (operator === "lte" && num === 0));
+}
+function validateCommonRuleValue(field, operator, value, label) {
+    if (!VALUELESS_OPERATORS.has(operator)) {
+        if (typeof value !== "string" || value.trim() === "")
+            return `${label}: value is required for ${field} ${operator}`;
+    }
+    if (field === "callAttempts" && typeof value === "string") {
+        if (!isSupportedCallAttemptsFilter(operator, value))
+            return `${label}: callAttempts only supports exact zero-call or has-call boundary filters`;
+    }
+    if (DATE_FILTER_FIELDS.has(field) && typeof value === "string" && value.trim() !== "") {
+        if (operator === "before" || operator === "after") {
+            if (isNaN(Date.parse(value)))
+                return `${label}: invalid date value "${value}" for ${operator}`;
+        }
+        else if (operator === "within" || operator === "not_within") {
+            if (!/^\d+(h|d|m)$/.test(value))
+                return `${label}: invalid duration value "${value}" — expected format like "7d", "24h", or "3m"`;
+        }
+    }
+    return null;
+}
+/** the API's validateAdvancedFilters, verbatim: the same verdict and the same message for the same payload */
+export function validateAdvancedFilters(payload) {
+    if (!Array.isArray(payload))
+        return { valid: false, error: "Filter payload must be an array of groups" };
+    if (payload.length > MAX_FILTER_GROUPS)
+        return { valid: false, error: `Too many filter groups (max ${MAX_FILTER_GROUPS})` };
+    for (let gi = 0; gi < payload.length; gi++) {
+        const group = payload[gi];
+        if (!group || typeof group !== "object")
+            return { valid: false, error: `Group ${gi}: invalid object` };
+        const { conjunction, rules } = group;
+        if (conjunction !== "AND" && conjunction !== "OR")
+            return { valid: false, error: `Group ${gi}: conjunction must be "AND" or "OR"` };
+        if (!Array.isArray(rules))
+            return { valid: false, error: `Group ${gi}: rules must be an array` };
+        if (rules.length > MAX_RULES_PER_GROUP)
+            return { valid: false, error: `Group ${gi}: too many rules (max ${MAX_RULES_PER_GROUP})` };
+        for (let ri = 0; ri < rules.length; ri++) {
+            const rule = rules[ri];
+            if (!rule || typeof rule !== "object")
+                return { valid: false, error: `Group ${gi} rule ${ri}: invalid object` };
+            const { field, operator, value } = rule;
+            if (typeof field !== "string")
+                return { valid: false, error: `Group ${gi} rule ${ri}: field must be a string` };
+            const cfKey = customFieldKey(field);
+            if (cfKey) {
+                if (typeof operator !== "string")
+                    return { valid: false, error: `Group ${gi} rule ${ri}: operator must be a string` };
+                if (!CF_OPERATORS.has(operator))
+                    return { valid: false, error: `Group ${gi} rule ${ri}: invalid operator "${operator}" for custom field "${field}"` };
+            }
+            else {
+                if (!VALID_FIELDS.has(field))
+                    return { valid: false, error: `Group ${gi} rule ${ri}: unknown field "${field}"` };
+                if (typeof operator !== "string")
+                    return { valid: false, error: `Group ${gi} rule ${ri}: operator must be a string` };
+                const validOps = ADVANCED_OPERATORS[field];
+                if (!validOps?.has(operator))
+                    return { valid: false, error: `Group ${gi} rule ${ri}: invalid operator "${operator}" for field "${field}"` };
+            }
+            // (Codex cli r3 m1) an array element that is not a string is refused here, as the app now does (the is_any_of branch trims each element)
+            if (value !== undefined && typeof value !== "string" && !(Array.isArray(value) && value.every((v) => typeof v === "string")))
+                return { valid: false, error: `Group ${gi} rule ${ri}: value must be a string or string[]` };
+            if (operator === "is_any_of") {
+                const values = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+                if (values.map((v) => v.trim()).filter(Boolean).length === 0)
+                    return { valid: false, error: `Group ${gi} rule ${ri}: at least one value is required` };
+            }
+            else {
+                const scalarValue = Array.isArray(value) ? value.join(",") : value;
+                const valueError = validateCommonRuleValue(field, normalizeOperator(field, operator), scalarValue, `Group ${gi} rule ${ri}`);
+                if (valueError)
+                    return { valid: false, error: valueError };
+            }
+        }
+    }
+    return { valid: true, groups: payload };
+}
+// ─── (Codex mcp/cli r5 h1 → r6 h1) VALID MEANS COMPILES ────────────────────────────────────────────────────────────────────────
+// The app's validateAdvancedFilters runs every rule through its strict compiler and refuses what the compiler would drop. This
+// surface carries the compiler's EXACT null-returning paths as one pure predicate — ./advanced-filter-compilability.ts, ported
+// verbatim from conduyt-app lib/advanced-filter-compilability.ts (slice B, on 0dab73baf), which the app proves equal to its real
+// compiler over an adversarial value matrix for every field, operator and custom-field operator
+// (lib/advanced-filter-compilability.test.ts) — so a rule accepted here is one the API accepts and the compiler keeps.
+import { advancedRuleCompiles } from "./advanced-filter-compilability.js";
+/** validateAdvancedFilters (the port) PLUS the compile verdict per rule: the same answer the API gives a write */
+export function validateAdvancedFiltersEffective(payload) {
+    const v = validateAdvancedFilters(payload);
+    if (!v.valid)
+        return v;
+    for (const [gi, group] of v.groups.entries())
+        for (const [ri, rule] of group.rules.entries()) {
+            if (!advancedRuleCompiles(rule))
+                return { valid: false, error: `Group ${gi} rule ${ri}: ${rule.field} ${rule.operator} cannot be applied to this value` };
+        }
+    return v;
+}

package/dist/tools/lead-pool.d.ts

@@ -24,4 +24,18 @@ export type TagRef = {
 /** the same plain-English criteria the Up for Grabs page prints under its header (lib/pool-filter-summary.ts in the app):
  *  a deleted tag (name null) stays visible because its id still filters every lead out; a failed lookup is said so */
 export declare function poolCriteriaPhrases(filter: PoolFilterShape, tags: TagRef[], tagLookupFailed?: boolean): string[];
+/** (Paul's signed concept 2026-09-25 §2–§3: pool filter sets, slice D parity) the two pool pages */
+export declare const POOL_PAGES: readonly ["up_for_grabs", "lead_pool"];
+export type PoolPage = (typeof POOL_PAGES)[number];
+/** the API's list row (lib/pool-page.ts toPoolFilterSetRow), validated in full: a stored payload that no longer compiles is answered
+ *  as filters: [] with valid: false (it matches nothing until repaired), so `valid` is safety-critical and every field is checked */
+export type PoolFilterSetRow = {
+    id: string;
+    name: string;
+    filters: unknown[];
+    isEnabled: boolean;
+    sortOrder: number;
+    valid: boolean;
+};
+export declare function isPoolFilterSetRow(r: unknown): r is PoolFilterSetRow;
 export declare function registerLeadPoolTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/lead-pool.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { formatResult } from "../client.js";
 import { patchGeneralSettings } from "./lifecycle.js";
+import { validateAdvancedFiltersEffective } from "./advanced-filter-rules.js";
 const EMPTY = { enabled: false, tagIds: [], sources: [], minScore: null, maxScore: null, createdWithinDays: null };
 function intOrNull(v) {
     return typeof v === "number" && Number.isInteger(v) ? v : null;
@@ -67,7 +68,90 @@ async function tagNamesFor(client, tagIds) {
     }
 }
 const score = z.number().int().min(0).max(1000);
+/** (Paul's signed concept 2026-09-25 §2–§3: pool filter sets, slice D parity) the two pool pages */
+export const POOL_PAGES = ["up_for_grabs", "lead_pool"];
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isPoolFilterSetRow(r) {
+    if (!r || typeof r !== "object" || Array.isArray(r))
+        return false;
+    const x = r;
+    if (typeof x.id !== "string" || !UUID_RE.test(x.id))
+        return false;
+    if (typeof x.name !== "string" || typeof x.isEnabled !== "boolean" || typeof x.valid !== "boolean")
+        return false;
+    if (typeof x.sortOrder !== "number" || !Number.isInteger(x.sortOrder) || x.sortOrder < 0 || x.sortOrder > 10_000)
+        return false;
+    if (!Array.isArray(x.filters))
+        return false;
+    // (Codex mcp r7 m1) a row flagged valid must COMPILE by the same verdict the writes use: a version-skewed or malformed answer is never surfaced as a valid enabled set
+    return x.valid ? validateAdvancedFiltersEffective(x.filters).valid : x.filters.length === 0;
+}
+const poolPage = z.enum(POOL_PAGES).describe("Which page: up_for_grabs (claim offers) or lead_pool (pull pool)");
+/** the API's validateAdvancedFilters, ported verbatim (./advanced-filter-rules.ts): the structural shape as a zod schema, then the
+ *  field / operator / value rules as a refinement — a schema-valid call is never a predictable 400 */
+const filtersSchema = z.array(z.object({
+    conjunction: z.enum(["AND", "OR"]),
+    rules: z.array(z.object({ field: z.string().min(1), operator: z.string().min(1), value: z.union([z.string(), z.array(z.string())]).optional() })).max(20),
+})).max(10).superRefine((groups, ctx) => {
+    const verdict = validateAdvancedFiltersEffective(groups); // (Codex mcp r5 h1) valid means COMPILES, as the API now judges
+    if (!verdict.valid)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: verdict.error });
+}).describe("The Contacts Advanced Filters payload, validated exactly like a Smart View's: up to 10 groups, each { conjunction: AND|OR, rules: [...] } with up to 20 rules of { field, operator, value }; fields and operators are the API's (unknown fields, operators a field does not take, a missing value for a value-bearing operator, an empty is_any_of, a bad date or duration are refused here). Tag rules take an ARRAY of tag names (one name per element), e.g. [{\"conjunction\":\"AND\",\"rules\":[{\"field\":\"tags\",\"operator\":\"not_contains\",\"value\":[\"VIP\"]}]}]");
+const setName = z.string().trim().min(1).max(80).describe("The set's name (1-80 characters, unique on its page)");
+/** (Codex mcp r1 h1) the page version is the CALLER's: the one its conduyt_list_pool_filter_sets read answered, so the API's
+ *  409 page_version_stale protects the state the agent decided on — never a version this tool would read for it */
+const pageVersion = z.string().min(1).describe("The pageVersion your conduyt_list_pool_filter_sets read answered (list first; a stale version is 409 page_version_stale: re-list, re-read the sets, retry)");
 export function registerLeadPoolTools(server, client) {
+    server.tool("conduyt_list_pool_filter_sets", "The named filter sets behind the gear on Up for Grabs or Lead Pool (admin only): each set's name, Advanced Filters payload, enabled flag and order, plus the page's current pageVersion — every write must name it, so LIST FIRST. The page shows the UNION of the enabled sets; a page with an enabled rule-less set — or no set once the legacy filter is retired — is OPEN to every unassigned lead.", { page: poolPage }, async ({ page }) => {
+        // the API's envelope: jsonResponse({ data: sets, pageVersion }) is { data: { data: sets, pageVersion } } on the wire
+        const result = (await client.get(`/api/v1/pool-filter-sets?page=${page}`));
+        // (Codex mcp r3 m1) FAIL CLOSED on a malformed answer: a missing or non-array set collection, or a set without its essential
+        // fields, is never presented as an empty page (an admin would create and enable a replacement against a valid version)
+        const rows = result?.data?.data;
+        const version = typeof result?.data?.pageVersion === "string" && result.data.pageVersion.trim() ? result.data.pageVersion : "";
+        if (!version)
+            throw new Error("GET /api/v1/pool-filter-sets answered no pageVersion — the API is older than this tool");
+        // (Codex mcp r4 m1) the WHOLE row contract: a row missing or mistyping any field (filters, sortOrder, the valid flag too) fails the call
+        if (!Array.isArray(rows) || !rows.every(isPoolFilterSetRow)) {
+            throw new Error("GET /api/v1/pool-filter-sets answered a malformed set collection — refusing to report an empty page (the API and this tool disagree on the response shape)");
+        }
+        return formatResult({ data: { sets: rows, pageVersion: version } });
+    });
+    server.tool("conduyt_create_pool_filter_set", "Add a named filter set to a pool page (admin only). A new set is a DRAFT (off) unless isEnabled is true. Enabling a set that would OPEN the whole page (no rule) is refused with 409 pool_opens unless acknowledgeOpensPool is true. Every tag name a rule carries must be a live tag (422 tag_missing); a custom field must exist (422 custom_field_missing). pageVersion is the one your list read answered (409 page_version_stale when the page moved since: re-list and retry).", {
+        page: poolPage,
+        name: setName,
+        filters: filtersSchema,
+        isEnabled: z.boolean().optional().describe("true to enable at once (default: a draft)"),
+        acknowledgeOpensPool: z.boolean().optional().describe("true to confirm a change that opens the whole page to every unassigned lead — for the page state your pageVersion names"),
+        pageVersion,
+    }, async ({ page, name, filters, isEnabled, acknowledgeOpensPool, pageVersion: version }) => formatResult(await client.post("/api/v1/pool-filter-sets", {
+        page, name, filters, pageVersion: version,
+        ...(isEnabled !== undefined ? { isEnabled } : {}),
+        ...(acknowledgeOpensPool !== undefined ? { acknowledgeOpensPool } : {}),
+    })));
+    server.tool("conduyt_update_pool_filter_set", "Rename, refilter, enable / disable or reorder a pool filter set (admin only). Pass only what changes. Switching a set on or changing its rules reconciles the open offers the page no longer shows; a change that OPENS the whole page needs acknowledgeOpensPool. pageVersion is the one your list read answered for the set's page (409 page_version_stale when the page moved since: re-list and retry).", {
+        id: z.string().uuid().describe("The set's UUID"),
+        name: setName.optional(),
+        filters: filtersSchema.optional(),
+        isEnabled: z.boolean().optional(),
+        sortOrder: z.number().int().min(0).max(10_000).optional().describe("The set's position on its page (0-10000)"),
+        acknowledgeOpensPool: z.boolean().optional(),
+        pageVersion,
+    }, async ({ id, pageVersion: version, ...updates }) => {
+        if (!Object.entries(updates).some(([k, v]) => k !== "acknowledgeOpensPool" && v !== undefined))
+            throw new Error("nothing to update: pass name, filters, isEnabled, sortOrder (and acknowledgeOpensPool when the change opens the page)");
+        return formatResult(await client.patch(`/api/v1/pool-filter-sets/${id}`, { pageVersion: version, ...updates }));
+    });
+    server.tool("conduyt_delete_pool_filter_set", "Remove a pool filter set (admin only). Removing the LAST enabled set once the legacy filter is retired OPENS the page to every unassigned lead: refused with 409 pool_opens unless acknowledgeOpensPool is true. pageVersion is the one your list read answered for the set's page.", {
+        id: z.string().uuid().describe("The set's UUID"),
+        acknowledgeOpensPool: z.boolean().optional(),
+        pageVersion,
+    }, async ({ id, acknowledgeOpensPool, pageVersion: version }) => {
+        const params = new URLSearchParams({ pageVersion: version });
+        if (acknowledgeOpensPool)
+            params.set("acknowledgeOpensPool", "true");
+        return formatResult(await client.del(`/api/v1/pool-filter-sets/${id}?${params}`));
+    });
     server.tool("conduyt_get_lead_pool_settings", "Read the admin-curated lead pool behind Up for Grabs / Lead Pool (settings.poolFilter + poolClaimDailyLimit). When enabled, an unassigned lead is offered only if it matches EVERY configured criterion: tagIds (any of), sources (any of), minScore (lead score >=), maxScore (lead score <=; min = max keeps one exact score), createdWithinDays (added to the CRM in the past N days: the contact's creation time — import, webhook, form, API or by hand; a re-import into an existing contact does not make it new). An empty criterion is skipped; enabled with nothing configured reads as disabled. Claims are gated by the same rules. tags carries the resolved tag names; criteria is the plain-English line the Up for Grabs page shows. Requires the settings scope.", {}, async () => {
         const result = (await client.get("/api/v1/settings"));
         const raw = result?.data ?? {};

package/dist/tools/saved-filters.js

@@ -37,17 +37,20 @@ export function registerSavedFilterTools(server, client) {
         const result = await client.get(`/api/v1/saved-filters${qs ? `?${qs}` : ""}`);
         return formatResult(result);
     });
-    server.tool("conduyt_create_saved_filter", "Save a named contact filter for one-click re-use — e.g. \"save a filter for Heather's Facebook leads\". Names are unique per user (409 on duplicate); max 50 saved filters per user. Requires the 'saved-filters' scope.", {
+    server.tool("conduyt_create_saved_filter", "Save a named contact filter for one-click re-use — e.g. \"save a filter for Heather's Facebook leads\". Since 2026-09-24 a saved filter IS a personal Smart View (the Smart Views tab), private to the key's user for every role (max 50 per user). Requires the 'saved-filters' scope.", {
         name: z.string().min(1).max(60).describe("Display name shown in the Saved dropdown (unique per user, max 60 chars)"),
         filters: filtersSchema,
         sortField: z.string().optional().describe("Sort field applied with the filter (default createdAt)"),
         sortOrder: z.enum(["asc", "desc"]).optional().describe("Sort direction (default desc)"),
         entityType: z.enum(["contact"]).optional().describe("Entity type (default 'contact')"),
     }, async (params) => {
-        const result = await client.post("/api/v1/saved-filters", params);
+        // (Smart Views 09-24) saved filters are personal Smart Views now: the same body creates one (personal for a
+        // rep key; an admin key creates a SHARED view, admins have no private filters); POST /saved-filters is retired (410)
+        // personal: true keeps the saved-filter contract for EVERY key (an admin key creates a private view, never a shared one)
+        const result = await client.post("/api/v1/smart-views", { name: params.name, filters: params.filters, sortField: params.sortField, sortOrder: params.sortOrder, personal: true });
         return formatResult(result);
     });
-    server.tool("conduyt_update_saved_filter", "Rename a saved filter or replace its filters/sort. Owner-only — you can only update your own saved filters. Use conduyt_list_saved_filters to find the id. Requires the 'saved-filters' scope.", {
+    server.tool("conduyt_update_saved_filter", "Rename a saved filter (a personal Smart View) or replace its filters/sort. Owner-only — a personal view is its owner's for every role. Use conduyt_list_saved_filters or conduyt_list_smart_views to find the id. Requires the 'saved-filters' scope.", {
         id: z.string().uuid().describe("Saved filter UUID (from conduyt_list_saved_filters)"),
         name: z.string().min(1).max(60).optional().describe("New display name (unique per user)"),
         filters: filtersSchema,
@@ -56,7 +59,7 @@ export function registerSavedFilterTools(server, client) {
     }, async ({ id, name, filters, sortField, sortOrder }) => {
         // Inline body (undefined fields drop out in JSON) — keeps the shape
         // readable by the contract verifier's static parser.
-        const result = await client.patch(`/api/v1/saved-filters/${encodeURIComponent(id)}`, {
+        const result = await client.patch(`/api/v1/smart-views/${encodeURIComponent(id)}`, {
             name,
             filters,
             sortField,
@@ -64,12 +67,12 @@ export function registerSavedFilterTools(server, client) {
         });
         return formatResult(result);
     });
-    server.tool("conduyt_delete_saved_filter", "Delete one of YOUR saved filters by id. Owner-only. Requires the 'saved-filters' scope.", {
+    server.tool("conduyt_delete_saved_filter", "Delete one of YOUR saved filters (a personal Smart View) by id. Owner-only. Requires the 'saved-filters' scope.", {
         // Strict UUID + encode — the id is interpolated into a DELETE path and
         // must never traverse out of the saved-filters endpoint.
         id: z.string().uuid().describe("Saved filter UUID (from conduyt_list_saved_filters)"),
     }, async ({ id }) => {
-        const result = await client.del(`/api/v1/saved-filters/${encodeURIComponent(id)}`);
+        const result = await client.del(`/api/v1/smart-views/${encodeURIComponent(id)}`);
         return formatResult(result);
     });
 }

package/dist/tools/smart-views.d.ts

@@ -1,3 +1,17 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ConduytClient } from "../client.js";
+/**
+ * (Smart Views Codex r5) GET /smart-views is paged, 100 a page, and says so (meta.total, meta.has_more and an order
+ * stamp that moves on every reorder, edit, create and delete). EVERY page is walked under the first page's stamp,
+ * counts only on the first page (the expensive part); a page read after the order shifted restarts the walk, so an
+ * AI caller never silently loses a view past row 100 and never sees one twice.
+ */
+export declare function listAllSmartViews(client: ConduytClient): Promise<{
+    data: Array<Record<string, unknown>>;
+    meta: {
+        total: number;
+        pages: number;
+        order_stamp: string;
+    };
+}>;
 export declare function registerSmartViewTools(server: McpServer, client: ConduytClient): void;

package/dist/tools/smart-views.js

@@ -14,11 +14,34 @@ const scheduleStepSchema = z.object({
     attemptNumber: z.number().int().min(1).max(20).describe("1 = the first call, 2 = the first retry, …"),
     delayMinutes: z.number().int().min(0).describe("Minutes to wait after the previous attempt before this one (0 = immediately)"),
 });
+/**
+ * (Smart Views Codex r5) GET /smart-views is paged, 100 a page, and says so (meta.total, meta.has_more and an order
+ * stamp that moves on every reorder, edit, create and delete). EVERY page is walked under the first page's stamp,
+ * counts only on the first page (the expensive part); a page read after the order shifted restarts the walk, so an
+ * AI caller never silently loses a view past row 100 and never sees one twice.
+ */
+export async function listAllSmartViews(client) {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const first = (await client.get("/api/v1/smart-views"));
+        const rows = [...first.data.data];
+        let meta = first.data.meta;
+        let shifted = false;
+        for (let page = 2; meta.has_more && page <= 50; page += 1) {
+            const next = (await client.get(`/api/v1/smart-views?page=${page}&counts=false`));
+            if (next.data.meta.order_stamp !== first.data.meta.order_stamp) {
+                shifted = true;
+                break;
+            }
+            rows.push(...next.data.data);
+            meta = next.data.meta;
+        }
+        if (!shifted)
+            return { data: rows, meta: { total: first.data.meta.total, pages: meta.page, order_stamp: first.data.meta.order_stamp } };
+    }
+    throw new Error("Smart Views kept changing while they were listed (a reorder or edit landed three times in a row); try again");
+}
 export function registerSmartViewTools(server, client) {
-    server.tool("conduyt_list_smart_views", "List the account's Smart Views in sidebar order with their lead counts and Smart Dialing settings (dialEnabled = it is a dialing priority; sortPosition = its rank; maxDialAttempts, maxDialAttemptsPerDay, dialCooldownMinutes, dialSchedule). Use it to answer \"what does the team dial first?\" or before changing a priority.", {}, async () => {
-        const result = await client.get("/api/v1/smart-views");
-        return formatResult(result);
-    });
+    server.tool("conduyt_list_smart_views", "List the account's Smart Views in sidebar order with their lead counts, audience (groupId + group name, members, isPersonal) and Smart Dialing settings (dialEnabled = it is a dialing priority; sortPosition = its rank; maxDialAttempts, maxDialAttemptsPerDay, dialCooldownMinutes, dialSchedule). Use it to answer \"what does the team dial first?\" or before changing a priority.", {}, async () => formatResult(await listAllSmartViews(client)));
     server.tool("conduyt_update_smart_view_dialing", "Change one Smart View's Smart Dialing settings (admin key): make it a priority or not, the lifetime attempt cap, the per-day cap (null = no daily cap, counted in the account timezone), the cooldown between calls to the same lead, the shared pool and when a pool lead is assigned, and the retry schedule. Only the fields you pass change. Use conduyt_reorder_smart_views to change WHICH priority it is.", {
         id: z.string().uuid().describe("Smart View UUID (from conduyt_list_smart_views)"),
         dialEnabled: z.boolean().optional().describe("true = this view is a Smart Dialing priority; false = agents no longer dial it"),
@@ -70,10 +93,39 @@ export function registerSmartViewTools(server, client) {
         const result = await client.patch("/api/v1/smart-views/dial-order", { order });
         return formatResult(result);
     });
+    server.tool("conduyt_set_smart_view_audience", "Who a SHARED Smart View is for (admin key): everyone on the account, one Team group (its CURRENT members, resolved when the view is read, so a rep added to the group later sees it and dials from it), or picked reps. A group replaces picked reps and vice versa. Personal views (a rep's own) have no audience.", {
+        id: z.string().uuid().describe("Smart View UUID (from conduyt_list_smart_views)"),
+        audience: z.enum(["everyone", "group", "reps"]).describe("everyone | group (pass groupId) | reps (pass memberIds)"),
+        groupId: z.string().uuid().optional().describe("The Team group (conduyt_list_groups) when audience = group"),
+        memberIds: z.array(z.string().uuid()).min(1).max(200).optional().describe("The reps' user ids when audience = reps"),
+    }, async ({ id, audience, groupId, memberIds }) => {
+        if (audience === "group" && !groupId)
+            throw new Error("audience = group needs groupId");
+        if (audience === "reps" && (!memberIds || memberIds.length === 0))
+            throw new Error("audience = reps needs memberIds");
+        const result = await client.patch(`/api/v1/smart-views/${encodeURIComponent(id)}`, {
+            groupId: audience === "group" ? groupId : null,
+            members: audience === "reps" ? (memberIds ?? []).map((userId) => ({ userId })) : [],
+        });
+        return formatResult(result);
+    });
     server.tool("conduyt_reorder_smart_views", "Set the SIDEBAR order of Smart Views (admin key). Pass EVERY view id from conduyt_list_smart_views in the wanted order (max 200, no duplicates) — views you leave out keep a stale position, so always send the full list. For the dialing priority use conduyt_set_smart_dialing_order, which only needs the dial-enabled ids.", {
         order: z.array(z.string().uuid()).min(1).max(200).describe("Every Smart View UUID, first = highest priority"),
     }, async ({ order }) => {
         const result = await client.patch("/api/v1/smart-views/reorder", { order });
         return formatResult(result);
     });
+    server.tool("conduyt_move_smart_view", "Move ONE Smart View next to another in the sidebar order (admin key): pass the moved view's id and exactly one anchor, beforeId (it lands directly above that view) or afterId (directly below). Every other view keeps its relative position; no size limit, so use this on accounts with more than 200 views (conduyt_reorder_smart_views is capped at 200 ids). The order is the Smart Dialing priority for dial-enabled views.", {
+        id: z.string().uuid().describe("The Smart View to move"),
+        beforeId: z.string().uuid().optional().describe("Land directly ABOVE this view (pass this or afterId, not both)"),
+        afterId: z.string().uuid().optional().describe("Land directly BELOW this view (pass this or beforeId, not both)"),
+    }, async ({ id, beforeId, afterId }) => {
+        const anchors = [beforeId, afterId].filter(Boolean);
+        if (anchors.length !== 1)
+            throw new Error("Pass exactly one of beforeId or afterId.");
+        if (anchors[0] === id)
+            throw new Error("A view cannot be anchored to itself.");
+        const result = await client.patch("/api/v1/smart-views/reorder", { move: beforeId ? { id, beforeId } : { id, afterId } });
+        return formatResult(result);
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.66.0",
+  "version": "4.68.0",
   "description": "MCP server for Conduyt CRM — expose CRM operations as AI-accessible tools",
   "type": "module",
   "main": "dist/index.js",

package/scripts/coverage-matrix.json

@@ -1,11 +1,11 @@
 {
-  "generatedAt": "2026-09-24T04:33:02.436Z",
-  "toolCount": 282,
-  "totalEndpoints": 1000,
+  "generatedAt": "2026-09-26T07:26:50.579Z",
+  "toolCount": 288,
+  "totalEndpoints": 1008,
   "counts": {
-    "covered": 262,
-    "excluded": 293,
-    "planned": 445,
+    "covered": 264,
+    "excluded": 295,
+    "planned": 449,
     "uncategorized": 0
   },
   "matrix": {
@@ -97,6 +97,14 @@
       "status": "excluded",
       "reason": "public unauthenticated surfaces (forms, booking, unsubscribe) — no key semantics"
     },
+    "POST /api/public/forms/:slug/upload-url": {
+      "status": "excluded",
+      "reason": "public unauthenticated surfaces (forms, booking, unsubscribe) — no key semantics"
+    },
+    "OPTIONS /api/public/forms/:slug/upload-url": {
+      "status": "excluded",
+      "reason": "public unauthenticated surfaces (forms, booking, unsubscribe) — no key semantics"
+    },
     "GET /api/v1/forms": {
       "status": "covered",
       "tools": [
@@ -145,6 +153,10 @@
       "status": "planned",
       "reason": "form management"
     },
+    "GET /api/v1/forms/:id/uploads": {
+      "status": "planned",
+      "reason": "form management"
+    },
     "POST /api/public/invoices/:id/payment-link": {
       "status": "excluded",
       "reason": "public unauthenticated surfaces (forms, booking, unsubscribe) — no key semantics"
@@ -3157,6 +3169,30 @@
       "status": "planned",
       "reason": "playbook management"
     },
+    "GET /api/v1/pool-filter-sets": {
+      "status": "covered",
+      "tools": [
+        "conduyt_list_pool_filter_sets"
+      ]
+    },
+    "POST /api/v1/pool-filter-sets": {
+      "status": "covered",
+      "tools": [
+        "conduyt_create_pool_filter_set"
+      ]
+    },
+    "PATCH /api/v1/pool-filter-sets/:id": {
+      "status": "covered",
+      "tools": [
+        "conduyt_update_pool_filter_set"
+      ]
+    },
+    "DELETE /api/v1/pool-filter-sets/:id": {
+      "status": "covered",
+      "tools": [
+        "conduyt_delete_pool_filter_set"
+      ]
+    },
     "GET /api/v1/products": {
       "status": "covered",
       "tools": [
@@ -3578,22 +3614,16 @@
       "reason": "saved filter management"
     },
     "POST /api/v1/saved-filters": {
-      "status": "covered",
-      "tools": [
-        "conduyt_create_saved_filter"
-      ]
+      "status": "planned",
+      "reason": "saved filter management"
     },
     "PATCH /api/v1/saved-filters/:id": {
-      "status": "covered",
-      "tools": [
-        "conduyt_update_saved_filter"
-      ]
+      "status": "planned",
+      "reason": "saved filter management"
     },
     "DELETE /api/v1/saved-filters/:id": {
-      "status": "covered",
-      "tools": [
-        "conduyt_delete_saved_filter"
-      ]
+      "status": "planned",
+      "reason": "saved filter management"
     },
     "GET /api/v1/schema/api-catalog": {
       "status": "covered",
@@ -3985,15 +4015,15 @@
       "reason": "smart list management"
     },
     "GET /api/v1/smart-views": {
+      "status": "planned",
+      "reason": "smart view management beyond summaries"
+    },
+    "POST /api/v1/smart-views": {
       "status": "covered",
       "tools": [
-        "conduyt_list_smart_views"
+        "conduyt_create_saved_filter"
       ]
     },
-    "POST /api/v1/smart-views": {
-      "status": "planned",
-      "reason": "smart view management beyond summaries"
-    },
     "GET /api/v1/smart-views/:id": {
       "status": "planned",
       "reason": "smart view management beyond summaries"
@@ -4001,12 +4031,16 @@
     "PATCH /api/v1/smart-views/:id": {
       "status": "covered",
       "tools": [
-        "conduyt_update_smart_view_dialing"
+        "conduyt_update_saved_filter",
+        "conduyt_update_smart_view_dialing",
+        "conduyt_set_smart_view_audience"
       ]
     },
     "DELETE /api/v1/smart-views/:id": {
-      "status": "planned",
-      "reason": "smart view management beyond summaries"
+      "status": "covered",
+      "tools": [
+        "conduyt_delete_saved_filter"
+      ]
     },
     "GET /api/v1/smart-views/dial-order": {
       "status": "covered",
@@ -4023,7 +4057,8 @@
     "PATCH /api/v1/smart-views/reorder": {
       "status": "covered",
       "tools": [
-        "conduyt_reorder_smart_views"
+        "conduyt_reorder_smart_views",
+        "conduyt_move_smart_view"
       ]
     },
     "GET /api/v1/sms-providers": {
@@ -4339,6 +4374,10 @@
       "status": "planned",
       "reason": "team management subroutes beyond list/invite"
     },
+    "POST /api/v1/users/me/welcomed": {
+      "status": "planned",
+      "reason": "team management subroutes beyond list/invite"
+    },
     "GET /api/v1/warmy-engine/health": {
       "status": "planned",
       "reason": "email warm-up engine surfaces"