conduyt-mcp 4.67.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.67.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-25T04:02:01.551Z",
-  "toolCount": 284,
-  "totalEndpoints": 1003,
+  "generatedAt": "2026-09-26T07:26:50.579Z",
+  "toolCount": 288,
+  "totalEndpoints": 1008,
   "counts": {
-    "covered": 260,
+    "covered": 264,
     "excluded": 295,
-    "planned": 448,
+    "planned": 449,
     "uncategorized": 0
   },
   "matrix": {
@@ -3071,6 +3071,10 @@
       "status": "planned",
       "reason": "notification surfaces"
     },
+    "GET /api/v1/ops/capacity": {
+      "status": "planned",
+      "reason": "operator capacity dashboard (#51, shipped 2026-09) — read-only queue/park telemetry; a typed conduyt_capacity_snapshot tool is agent-relevant for throughput questions"
+    },
     "GET /api/v1/phone-numbers": {
       "status": "planned",
       "reason": "phone number inventory"
@@ -3165,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": [