conduyt 1.52.0 → 1.54.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";
@@ -2683,6 +2684,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");
@@ -3527,11 +3561,29 @@ reports
 const smartViews = program.command("smart-views").description("Smart Views and their Smart Dialing priorities");
 smartViews
     .command("list")
-    .description("List Smart Views in sidebar order (= Smart Dialing priority) with lead counts and dialing settings")
+    .description("List Smart Views in sidebar order (= Smart Dialing priority) with lead counts, audience (groupId / members / isPersonal) and dialing settings")
     .option("--dialing", "only the dial-enabled views (the Smart Dialing priorities)")
     .action(run(async (client, opts) => {
-    const views = (await client.get("/api/v1/smart-views"));
-    const rows = Array.isArray(views) ? views : [];
+    let rows = null;
+    for (let attempt = 0; attempt < 3 && rows === null; attempt += 1) {
+        const first = (await client.get("/api/v1/smart-views"));
+        const walked = [...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;
+            }
+            walked.push(...next.data.data);
+            meta = next.data.meta;
+        }
+        if (!shifted)
+            rows = walked;
+    }
+    if (rows === null)
+        throw new Error("Smart Views kept changing while they were listed; try again.");
     const sorted = [...rows].sort((a, b) => Number(a.sortPosition ?? 0) - Number(b.sortPosition ?? 0));
     return opts.dialing ? sorted.filter((v) => v.dialEnabled === true) : sorted;
 }));
@@ -3606,6 +3658,31 @@ smartViews
         throw new Error("Nothing to change. Pass --enable/--disable, --max-attempts, --per-day, --cooldown or --schedule.");
     return client.patch(`/api/v1/smart-views/${encodeURIComponent(id)}`, body);
 }));
+smartViews
+    .command("audience <id>")
+    .description("Who a shared Smart View is for (PATCH): everyone, one Team group (its current members, resolved when the view is read), or picked reps. A group replaces picked reps and vice versa.")
+    .option("--everyone", "every rep on the account")
+    .option("--group <groupId>", "one Team group (see: conduyt groups list)")
+    .option("--reps <userIds>", "comma-separated user ids of the reps")
+    .action(run(async (client, id, opts) => {
+    assertUuid(id, "smart view id");
+    const picked = [opts.everyone ? "everyone" : null, opts.group ? "group" : null, opts.reps ? "reps" : null].filter(Boolean);
+    if (picked.length !== 1)
+        throw new Error("Pass exactly one of --everyone, --group <groupId> or --reps <userIds>.");
+    if (opts.group) {
+        assertUuid(opts.group, "group id");
+        return client.patch(`/api/v1/smart-views/${encodeURIComponent(id)}`, { groupId: opts.group, members: [] });
+    }
+    if (opts.reps) {
+        const ids = opts.reps.split(",").map((x) => x.trim()).filter(Boolean);
+        if (ids.length === 0)
+            throw new Error("--reps needs at least one user id.");
+        for (const u of ids)
+            assertUuid(u, "user id");
+        return client.patch(`/api/v1/smart-views/${encodeURIComponent(id)}`, { groupId: null, members: ids.map((userId) => ({ userId })) });
+    }
+    return client.patch(`/api/v1/smart-views/${encodeURIComponent(id)}`, { groupId: null, members: [] });
+}));
 smartViews
     .command("dial-order [ids...]")
     .description("No ids: show the Smart Dialing priorities, uncapped (every dial-enabled view in dial order + candidates). With ids: set the priority order — every dial-enabled view id, first = dialed first (the server keeps non-priority views in their slots)")
@@ -3620,6 +3697,21 @@ smartViews
         assertUuid(id, "smart view id");
     return client.patch("/api/v1/smart-views/dial-order", { order: ids });
 }));
+smartViews
+    .command("move <id>")
+    .description("Move ONE Smart View next to another in the sidebar order (= Smart Dialing priority). No size limit: use this on accounts with more than 200 views")
+    .option("--before <viewId>", "land directly above this view")
+    .option("--after <viewId>", "land directly below this view")
+    .action(run(async (client, id, opts) => {
+    assertUuid(id, "smart view id");
+    const anchors = [opts.before, opts.after].filter(Boolean);
+    if (anchors.length !== 1)
+        throw new Error("Pass exactly one of --before <viewId> or --after <viewId>.");
+    assertUuid(anchors[0], "anchor view id");
+    if (anchors[0] === id)
+        throw new Error("A view cannot be anchored to itself.");
+    return client.patch("/api/v1/smart-views/reorder", { move: opts.before ? { id, beforeId: opts.before } : { id, afterId: opts.after } });
+}));
 smartViews
     .command("reorder <ids...>")
     .description("Set the SIDEBAR order of Smart Views. Pass EVERY view id; views left out keep a stale position. For the dialing priority use dial-order")

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,7 +1,7 @@
 {
   "name": "conduyt",
-  "version": "1.52.0",
-  "description": "Command-line interface for Conduyt CRM — manage contacts, deals, pipelines, and run insight queries from your terminal.",
+  "version": "1.54.0",
+  "description": "Command-line interface for Conduyt CRM \u2014 manage contacts, deals, pipelines, and run insight queries from your terminal.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -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",