conduyt 1.53.0 → 1.55.0

package/dist/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/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/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync, writeFileSync } from "node:fs";
+import { addPoolFilterSet, listPoolFilterSets, removePoolFilterSet, updatePoolFilterSet } from "./pool-filter-sets.js";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { Command } from "commander";
@@ -2096,6 +2097,45 @@ webhooks
         Object.assign(body, jsonArg(opts.json, "--json"));
     return client.post("/api/v1/webhooks/manage", body);
 }));
+// ---- drip send barrier recovery (Smart Views slice A, Codex r70 m5) ----
+// A drip step whose provider outcome was unconfirmed is PARKED behind a barrier (a parked webhook log and/or the
+// processor's marker). An operator (admin/owner) cancels it here: cancel-only leaves the barrier standing (nothing is
+// sent); --skip assumes the step was delivered (the processor advances without sending); --resend sends the step AGAIN
+// (a possible duplicate SMS) and is refused without --acknowledge-duplicate-risk.
+const uuidArg = (raw, name) => {
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(raw))
+        throw new Error(`${name} must be a UUID`);
+    return raw;
+};
+const barrierBody = (opts) => {
+    if (opts.skip && opts.resend)
+        throw new Error("pass --skip or --resend, not both");
+    if (opts.resend && !opts.acknowledgeDuplicateRisk)
+        throw new Error("--resend may deliver the step TWICE (its outcome was unconfirmed): pass --acknowledge-duplicate-risk, or --skip to advance without sending");
+    const body = {};
+    if (opts.skip)
+        body.resolution = "skip";
+    if (opts.resend) {
+        body.resolution = "resend";
+        body.confirm = "RESEND_UNCONFIRMED_DRIP";
+    }
+    return body;
+};
+webhooks
+    .command("cancel-log <id>")
+    .description("Cancel ONE parked / queued / failed webhook log of an unconfirmed drip send (POST /webhook-logs/{id}/cancel; admin/owner, webhooks scope). Cancel-only by default: the barrier stands")
+    .option("--skip", "assume the step was delivered: the processor advances without sending")
+    .option("--resend", "send the step again (duplicate risk: needs --acknowledge-duplicate-risk; refused 409 step_already_sent when the step already carries sent evidence: use --skip)")
+    .option("--acknowledge-duplicate-risk", "you accept the step may be delivered twice")
+    .action(run(async (client, id, opts) => client.post(`/api/v1/webhook-logs/${uuidArg(id, "id")}/cancel`, barrierBody(opts))));
+const dripEnrollments = program.command("drip-enrollments").description("Drip enrollment recovery");
+dripEnrollments
+    .command("cancel-barrier <id>")
+    .description("Cancel a drip enrollment's whole send barrier (POST /drip-enrollments/{id}/cancel-barrier; admin/owner, drip-enrollments scope) — every parked / queued / failed log, including a marker-only barrier with no log at all. Cancel-only by default: the barrier stands")
+    .option("--skip", "assume the current step was delivered: the processor advances without sending")
+    .option("--resend", "send the step again (duplicate risk: needs --acknowledge-duplicate-risk; refused 409 step_already_sent when the step already carries sent evidence: use --skip)")
+    .option("--acknowledge-duplicate-risk", "you accept the step may be delivered twice")
+    .action(run(async (client, id, opts) => client.post(`/api/v1/drip-enrollments/${uuidArg(id, "id")}/cancel-barrier`, barrierBody(opts))));
 // ---- dnc (Do Not Call) ----
 // NOTE: an AI agent's API key must be granted the `dnc` scope to manage the DNC
 // list. Reading also requires dialer:view; adding a litigator entry and removals
@@ -2683,6 +2723,39 @@ leadPool
     const offers = Array.isArray(data.offers) ? data.offers : [];
     return { data: { offers, count: offers.length, poolFilter: pf, criteria: poolCriteriaPhrases(filter, pf?.tags ?? [], pf?.tagLookupFailed === true) } };
 }));
+// ─── pool filter sets (Paul's signed concept 2026-09-25 §2–§3, slice D parity with the gear and the MCP tools): the
+// command bodies live in ./pool-filter-sets.ts, tested against the API's exact wire envelope ───
+leadPool
+    .command("filter-sets")
+    .description("The named filter sets behind the gear on a pool page (admin only; GET /api/v1/pool-filter-sets): name, Advanced Filters payload, enabled flag, order — and the page's pageVersion every write must name (LIST FIRST). The page shows the UNION of the enabled sets.")
+    .requiredOption("--page <page>", "up_for_grabs or lead_pool")
+    .action(run(async (client, opts) => listPoolFilterSets(client, opts)));
+leadPool
+    .command("add-filter-set")
+    .description("Add a named filter set to a pool page (admin only; POST /api/v1/pool-filter-sets). A new set is a DRAFT unless --enabled on. A change that OPENS the whole page (an enabled rule-less set) needs --acknowledge-opens-pool (else 409 pool_opens). Tag rules must name live tags (422 tag_missing). --page-version is the pageVersion your filter-sets read answered (409 page_version_stale when the page moved since: re-list and retry). --filters is validated exactly like the API validates it.")
+    .requiredOption("--page <page>", "up_for_grabs or lead_pool")
+    .requiredOption("--name <name>", "the set's name (1-80 characters, unique on its page)")
+    .requiredOption("--filters <json>", "the Advanced Filters payload (a JSON array of ≤ 10 groups, each { conjunction: AND|OR, rules: [≤ 20 of { field, operator, value }] })")
+    .requiredOption("--page-version <version>", "the pageVersion your `lead-pool filter-sets` read answered")
+    .option("--enabled <on|off>", "enable at once (default: a draft)")
+    .option("--acknowledge-opens-pool", "confirm a change that opens the whole page to every unassigned lead (for the page state --page-version names)")
+    .action(run(async (client, opts) => addPoolFilterSet(client, opts)));
+leadPool
+    .command("update-filter-set <id>")
+    .description("Rename, refilter, enable / disable or reorder a pool filter set (admin only; PATCH /api/v1/pool-filter-sets/:id). Pass only what changes. A change that OPENS the whole page needs --acknowledge-opens-pool. --page-version is the pageVersion your filter-sets read answered for the set's page (409 page_version_stale when the page moved since: re-list and retry).")
+    .requiredOption("--page-version <version>", "the pageVersion your `lead-pool filter-sets` read answered for the set's page")
+    .option("--name <name>", "new name (1-80 characters)")
+    .option("--filters <json>", "new Advanced Filters payload (a JSON array of groups)")
+    .option("--enabled <on|off>", "switch the set on or off")
+    .option("--sort-order <n>", "the set's position on its page (0-10000)")
+    .option("--acknowledge-opens-pool", "confirm a change that opens the whole page")
+    .action(run(async (client, id, opts) => updatePoolFilterSet(client, id, opts)));
+leadPool
+    .command("remove-filter-set <id>")
+    .description("Remove a pool filter set (admin only; DELETE /api/v1/pool-filter-sets/:id). Removing the last enabled set once the legacy filter is retired OPENS the page: refused with 409 pool_opens unless --acknowledge-opens-pool. --page-version is the pageVersion your filter-sets read answered for the set's page.")
+    .requiredOption("--page-version <version>", "the pageVersion your `lead-pool filter-sets` read answered for the set's page")
+    .option("--acknowledge-opens-pool", "confirm a removal that opens the whole page")
+    .action(run(async (client, id, opts) => removePoolFilterSet(client, id, opts)));
 const lifecycle = program
     .command("lifecycle")
     .description("Lifecycle settings: lead master statuses, intake-deal creation, how the tenant works leads, and lost propagation");

package/dist/pool-filter-sets.js

@@ -0,0 +1,133 @@
+/**
+ * Pool filter sets (Paul's signed Smart Views concept 2026-09-25 §2–§3, slice D parity with the gear and the MCP tools):
+ * the command bodies, as pure functions over the API client so they are tested against the API's EXACT wire envelope
+ * (jsonResponse({ data: sets, pageVersion }) is { data: { data, pageVersion } }) and never make a request they should not.
+ */
+import { validateAdvancedFiltersEffective } from "./advanced-filter-rules.js";
+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 cli 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;
+}
+export function poolPageArg(raw) {
+    if (raw === "up_for_grabs" || raw === "lead_pool")
+        return raw;
+    throw new Error(`--page takes up_for_grabs or lead_pool (got '${raw ?? ""}')`);
+}
+/** (Codex mcp r1 h1) the page version is the CALLER's — the one its `lead-pool filter-sets` read answered — so the API's
+ *  409 page_version_stale protects the state the caller decided on; the CLI never reads a version on the caller's behalf */
+export function pageVersionFlag(raw) {
+    if (typeof raw !== "string" || raw.trim().length === 0)
+        throw new Error("--page-version is required: the pageVersion your `conduyt lead-pool filter-sets --page …` read answered (list first; a stale version is 409 page_version_stale: re-list, re-read the sets, retry)");
+    return raw.trim();
+}
+/** (Codex cli r2 h2) a set id is a UUID and nothing else: an id like ../contacts/<uuid> would normalise into another route */
+export function poolSetIdArg(raw) {
+    const id = raw.trim();
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id))
+        throw new Error("pool filter set id must be a UUID.");
+    return encodeURIComponent(id);
+}
+/** the API's validateAdvancedFilters, ported verbatim (./advanced-filter-rules.ts): a flag-valid payload is never a predictable 400 */
+export function filtersFlag(raw) {
+    if (raw === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("--filters must be JSON: the Contacts Advanced Filters payload, an array of groups");
+    }
+    if (!Array.isArray(parsed))
+        throw new Error("--filters must be a JSON ARRAY of groups, e.g. '[{\"conjunction\":\"AND\",\"rules\":[{\"field\":\"source\",\"operator\":\"equals\",\"value\":\"Kloudi\"}]}]' (tag rules take an array of names)");
+    const verdict = validateAdvancedFiltersEffective(parsed); // (Codex cli r5 h1) valid means COMPILES, as the API now judges
+    if (!verdict.valid)
+        throw new Error(`--filters: ${verdict.error}`);
+    return parsed;
+}
+export function poolSetNameFlag(raw) {
+    const name = raw.trim();
+    if (name.length === 0 || name.length > 80)
+        throw new Error("--name must be 1-80 characters");
+    return name;
+}
+export function onOffFlag(raw, flag) {
+    const v = raw.trim().toLowerCase();
+    if (v === "on" || v === "true" || v === "yes")
+        return true;
+    if (v === "off" || v === "false" || v === "no")
+        return false;
+    throw new Error(`${flag} takes on or off (got '${raw}').`);
+}
+function sortOrderFlag(raw) {
+    if (raw === undefined)
+        return undefined;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0 || n > 10_000)
+        throw new Error("--sort-order takes a position 0-10000");
+    return n;
+}
+export async function listPoolFilterSets(client, opts) {
+    const page = poolPageArg(opts.page);
+    const result = (await client.get(`/api/v1/pool-filter-sets?page=${page}`));
+    const pageVersion = typeof result?.data?.pageVersion === "string" && result.data.pageVersion.trim() ? result.data.pageVersion : "";
+    if (!pageVersion)
+        throw new Error("GET /api/v1/pool-filter-sets answered no pageVersion — the API is older than this CLI");
+    // (Codex cli r3 m2) 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 (the list is the state snapshot every write is decided on)
+    const rows = result?.data?.data;
+    // (Codex cli 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 CLI disagree on the response shape)");
+    }
+    return { data: { sets: rows, pageVersion } };
+}
+export async function addPoolFilterSet(client, opts) {
+    const page = poolPageArg(opts.page);
+    const body = { page, name: poolSetNameFlag(opts.name), filters: filtersFlag(opts.filters) ?? [], pageVersion: pageVersionFlag(opts.pageVersion) };
+    if (opts.enabled !== undefined)
+        body.isEnabled = onOffFlag(opts.enabled, "--enabled");
+    if (opts.acknowledgeOpensPool)
+        body.acknowledgeOpensPool = true;
+    return client.post("/api/v1/pool-filter-sets", body);
+}
+export async function updatePoolFilterSet(client, rawId, opts) {
+    const id = poolSetIdArg(rawId);
+    const body = {};
+    if (opts.name !== undefined)
+        body.name = poolSetNameFlag(opts.name);
+    const filters = filtersFlag(opts.filters);
+    if (filters !== undefined)
+        body.filters = filters;
+    if (opts.enabled !== undefined)
+        body.isEnabled = onOffFlag(opts.enabled, "--enabled");
+    const sortOrder = sortOrderFlag(opts.sortOrder);
+    if (sortOrder !== undefined)
+        body.sortOrder = sortOrder;
+    if (Object.keys(body).length === 0)
+        throw new Error("nothing to change — pass at least one of --name, --filters, --enabled, --sort-order");
+    if (opts.acknowledgeOpensPool)
+        body.acknowledgeOpensPool = true;
+    body.pageVersion = pageVersionFlag(opts.pageVersion);
+    return client.patch(`/api/v1/pool-filter-sets/${id}`, body);
+}
+export async function removePoolFilterSet(client, rawId, opts) {
+    const id = poolSetIdArg(rawId);
+    const params = new URLSearchParams({ pageVersion: pageVersionFlag(opts.pageVersion) });
+    if (opts.acknowledgeOpensPool)
+        params.set("acknowledgeOpensPool", "true");
+    return client.del(`/api/v1/pool-filter-sets/${id}?${params}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt",
-  "version": "1.53.0",
+  "version": "1.55.0",
   "description": "Command-line interface for Conduyt CRM — manage contacts, deals, pipelines, and run insight queries from your terminal.",
   "type": "module",
   "main": "dist/index.js",
@@ -18,9 +18,11 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "start": "tsx src/index.ts",
-    "prepublishOnly": "npm run check:version && npm run build && node --import tsx --experimental-test-module-mocks --test src/*.test.ts",
+    "prepublishOnly": "npm run check:version && npm run build && node --import tsx --experimental-test-module-mocks --test src/*.test.ts && ENFORCE=1 node scripts/verify-compilability.mjs",
     "test": "node --import tsx --test src/*.test.ts",
-    "check:version": "node -e \"const p=require('./package.json').version,l=require('./package-lock.json');if(l.version!==p||l.packages[''].version!==p){console.error('lockfile version != '+p);process.exit(1)}console.log('Version sync OK: '+p)\""
+    "check:version": "node -e \"const p=require('./package.json').version,l=require('./package-lock.json');if(l.version!==p||l.packages[''].version!==p){console.error('lockfile version != '+p);process.exit(1)}console.log('Version sync OK: '+p)\"",
+    "compilability:refresh": "node scripts/refresh-compilability.mjs",
+    "verify:compilability": "node scripts/verify-compilability.mjs"
   },
   "keywords": [
     "conduyt",