conduyt 1.56.0 → 1.58.0

package/README.md

@@ -40,6 +40,11 @@ conduyt insights summary                # run an AI insight query
 conduyt insights saved_report --report "Lead Activity" --period last_7_days   # run any saved report as a tool
 conduyt insights dashboard --dashboard Floor --period today                   # run every tile of a board
 conduyt insights report_catalog                                                # what this key can run
+conduyt sequences list --type sms --on   # Email and SMS sequences (--archived, --summary)
+conduyt sequences senders sms           # who can send an SMS sequence (each member's line)
+conduyt sequences stats <id>            # sends, opens, clicks in total and per step
+conduyt sequences people <id> --all-active   # every live run; status and endedReason per run
+conduyt sequences check <id> <contactId...>  # who is eligible before enrolling
 conduyt messages transports             # what a workflow Send SMS step can speak through today (Twilio numbers, Project Blue lines, the WhatsApp sender)
 conduyt whatsapp status                 # WhatsApp via your Twilio: connected? from which sender
 conduyt whatsapp senders                # the senders Twilio lists for the account (ONLINE = connectable)

package/dist/index.js

@@ -953,7 +953,7 @@ messages
 })}`)));
 messages
     .command("send")
-    .description("Log/create a message (POST /messages). NOTE: outbound SMS is rejected here — use `messages send-sms` for real SMS delivery")
+    .description("Log/create a message (POST /messages). NOTE: outbound SMS is rejected here — use `messages send-sms` for real SMS delivery. An inbound SMS STOP or START with --from records that number's opt-out or opt-in (STOP also stops the contact's sequences and drips); the answer then carries smsConsent {keyword, fromNumber, applied, reason: number_not_on_contact | number_not_canonicalizable}")
     .option("--contact <id>", "contact UUID (required)")
     .option("--channel <channel>", "sms | email (required)")
     .option("--direction <direction>", "inbound | outbound (required)")
@@ -1458,7 +1458,7 @@ automations
     .action(run(async (client, opts) => client.post("/api/v1/automations/validate", bodyFromJsonOrFile(opts))));
 automations
     .command("import")
-    .description("Create a workflow (with optional name resolution). Provide the body via --json or --file (needs name + triggerEvent + graph)")
+    .description("Create a workflow (with optional name resolution). Provide the body via --json or --file (needs name + triggerEvent + graph). A sequence step is the action enroll_in_sequence with config {sequenceId, enrollAction: add (default) | remove}; add needs the sequence to allow automation enrollment")
     .option("--json <json>", "full request body as JSON")
     .option("--file <path>", "read the request body from a JSON file")
     .option("--resolve-names", "set resolveNames=true so name fields in node configs are converted to ids")
@@ -2143,6 +2143,275 @@ webhooks
     .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))));
+// ---------------------------------------------------------------------------
+// Sequences (one model for Email and SMS since 2026-09-30): steps send saved templates of the sequence's channel a
+// number of days apart inside a send window; a run stops on a reply, a booked meeting, an opt-out, a closed deal or a
+// removal. Provider drip timetables are the `drip-enrollments` group, a different thing.
+// ---------------------------------------------------------------------------
+const sequences = program.command("sequences").description("Email and SMS sequences built from saved templates: list, create, settings, On/Off, archive, enroll with a check first, who is in them and how each run ended");
+const SEQUENCE_SETTING_FLAGS = [
+    ["--sender <userId>", "the team member the messages are from (must be an active member): email from their on-domain address, SMS from their assigned line; pass none for the workspace default"],
+    ["--stop-on-reply <on|off>", "stop a contact's run when they reply to any message of the sequence (default on)"],
+    ["--stop-on-meeting <on|off>", "stop the run when a meeting is booked through any Conduyt calendar (default on)"],
+    ["--stop-on-opt-out <on|off>", "stop the run when the contact opts out: unsubscribe, or STOP for SMS (default on)"],
+    ["--stop-on-bounce <on|off>", "email only: stop the run on a hard bounce; a soft bounce waits and retries (default on)"],
+    ["--stop-on-deal-closed <on|off>", "stop a contact's run when any of their deals closes, won or lost, on any stage of a closed kind (default on)"],
+    ["--allow-automation-enroll <on|off>", "let the automation action enroll_in_sequence put contacts in (default on)"],
+    ["--allow-reenroll <on|off>", "let a contact go through it again once their earlier run ENDED (default off); a live or paused run is never restarted"],
+    ["--weekdays-only <on|off>", "send Monday to Friday only, in the contact's time zone (default on)"],
+    ["--send-from <hour>", "first hour of the send window, 0-23 local (default 9)"],
+    ["--send-until <hour>", "end of the send window, 1-24 local, exclusive (default 17); a step due outside the window waits for the next opening"],
+];
+function sequenceSettingsBody(opts) {
+    const body = {};
+    if (opts.sender !== undefined)
+        body.senderUserId = opts.sender === "none" ? null : uuidArg(opts.sender, "--sender");
+    if (opts.stopOnReply !== undefined)
+        body.autoUnenrollOnReply = onOffArg(opts.stopOnReply, "--stop-on-reply");
+    if (opts.stopOnMeeting !== undefined)
+        body.autoUnenrollOnMeeting = onOffArg(opts.stopOnMeeting, "--stop-on-meeting");
+    if (opts.stopOnOptOut !== undefined)
+        body.autoUnenrollOnUnsubscribe = onOffArg(opts.stopOnOptOut, "--stop-on-opt-out");
+    if (opts.stopOnBounce !== undefined)
+        body.autoUnenrollOnBounce = onOffArg(opts.stopOnBounce, "--stop-on-bounce");
+    if (opts.stopOnDealClosed !== undefined)
+        body.autoUnenrollOnDealClosed = onOffArg(opts.stopOnDealClosed, "--stop-on-deal-closed");
+    if (opts.allowAutomationEnroll !== undefined)
+        body.allowAutomationEnroll = onOffArg(opts.allowAutomationEnroll, "--allow-automation-enroll");
+    if (opts.allowReenroll !== undefined)
+        body.allowReenroll = onOffArg(opts.allowReenroll, "--allow-reenroll");
+    if (opts.weekdaysOnly !== undefined)
+        body.weekdaysOnly = onOffArg(opts.weekdaysOnly, "--weekdays-only");
+    for (const [flag, key, lo, hi] of [["sendFrom", "sendStartHour", 0, 23], ["sendUntil", "sendEndHour", 1, 24]]) {
+        const raw = opts[flag];
+        if (raw === undefined)
+            continue;
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < lo || n > hi)
+            throw new Error(`--${flag === "sendFrom" ? "send-from" : "send-until"} must be a whole hour, ${lo} to ${hi}.`);
+        body[key] = n;
+    }
+    return body;
+}
+/** --steps: JSON array of {templateId, waitDays}, or "tpl-id:days,tpl-id:days" (the first step's wait is 0) */
+function sequenceStepsArg(raw) {
+    const t = raw.trim();
+    if (t.startsWith("[")) {
+        let v;
+        try {
+            v = JSON.parse(t);
+        }
+        catch {
+            throw new Error("--steps must be a JSON array of {templateId, waitDays} or a list like id:0,id:3.");
+        }
+        if (!Array.isArray(v) || v.length === 0)
+            throw new Error("--steps needs at least one step.");
+        return v.map((row, i) => {
+            const r = (row ?? {});
+            if (typeof r.templateId !== "string")
+                throw new Error(`--steps[${i}] needs a templateId.`);
+            const wait = r.waitDays === undefined ? (i === 0 ? 0 : 1) : Number(r.waitDays);
+            if (!Number.isInteger(wait) || wait < 0)
+                throw new Error(`--steps[${i}].waitDays must be a whole number of days.`);
+            return { templateId: r.templateId, waitDays: i === 0 ? 0 : wait };
+        });
+    }
+    const parts = t.split(",").map((p) => p.trim()).filter(Boolean);
+    if (parts.length === 0)
+        throw new Error("--steps needs at least one step.");
+    return parts.map((p, i) => {
+        const [id, days] = p.split(":");
+        const wait = days === undefined ? (i === 0 ? 0 : 1) : Number(days);
+        if (!Number.isInteger(wait) || wait < 0)
+            throw new Error(`--steps step ${i + 1}: the wait must be a whole number of days (templateId:days).`);
+        return { templateId: uuidArg(id, "--steps"), waitDays: i === 0 ? 0 : wait };
+    });
+}
+function withSequenceSettingFlags(cmd) {
+    let c = cmd;
+    for (const [flag, desc] of SEQUENCE_SETTING_FLAGS)
+        c = c.option(flag, desc);
+    return c;
+}
+sequences
+    .command("list")
+    .description("List sequences (GET /emails/sequences), newest first: type (email | sms), isActive (On/Off), steps, senderUserId and sender, the stop rules, allowAutomationEnroll, allowReenroll, weekdaysOnly, sendStartHour, sendEndHour, archivedAt, people in it now. Archived ones are left out unless --archived. An API key sees only the channel(s) it is scoped to")
+    .option("--type <email|sms>", "only this channel")
+    .option("--on", "only sequences that are On")
+    .option("--off", "only sequences that are Off")
+    .option("--archived", "archived sequences only")
+    .option("--summary", "a light row per sequence (view=summary): id, name, type, isActive, dates, enrolledCount, description cut to 300 characters, stepCount")
+    .option("--page <n>", "page number")
+    .option("--limit <n>", "results per page (per_page, max 200)")
+    .action(run(async (client, opts) => {
+    const params = {};
+    if (opts.type !== undefined) {
+        if (opts.type !== "email" && opts.type !== "sms")
+            throw new Error("--type must be email or sms.");
+        params.type = opts.type;
+    }
+    if (opts.on && opts.off)
+        throw new Error("--on and --off exclude each other.");
+    if (opts.on)
+        params.is_active = "true";
+    if (opts.off)
+        params.is_active = "false";
+    if (opts.archived)
+        params.archived = "true";
+    if (opts.summary)
+        params.view = "summary";
+    if (opts.page !== undefined)
+        params.page = opts.page;
+    if (opts.limit !== undefined)
+        params.per_page = opts.limit;
+    return client.get(`/api/v1/emails/sequences${buildQuery(params)}`);
+}));
+sequences
+    .command("get <id>")
+    .description("One sequence with its steps (template per step, wait in days), sender, send window, stop rules, enrollment switches, archivedAt, people in it now and enrollmentStats (people per run status)")
+    .action(run(async (client, id) => client.get(`/api/v1/emails/sequences/${uuidArg(id, "id")}`)));
+withSequenceSettingFlags(sequences
+    .command("create <name>")
+    .description("Create an Email or SMS sequence from saved templates (POST /emails/sequences). Created Off unless --on. The type cannot change afterwards")
+    .option("--type <email|sms>", "the channel (default email)")
+    .option("--steps <steps>", "the steps in order: templateId:days,templateId:days (the first step's wait is 0) or a JSON array of {templateId, waitDays}")
+    .option("--description <text>", "description")
+    .option("--on", "turn it On right away")
+    .option("--json <json>", "full JSON body, merged over the flags")).action(run(async (client, name, opts) => {
+    const body = { name, ...sequenceSettingsBody(opts) };
+    if (opts.type !== undefined) {
+        if (opts.type !== "email" && opts.type !== "sms")
+            throw new Error("--type must be email or sms.");
+        body.type = opts.type;
+    }
+    if (opts.steps !== undefined)
+        body.steps = sequenceStepsArg(opts.steps);
+    if (opts.description !== undefined)
+        body.description = opts.description;
+    if (opts.on)
+        body.isActive = true;
+    if (opts.json !== undefined)
+        Object.assign(body, jsonArg(opts.json, "--json"));
+    if (!Array.isArray(body.steps) || body.steps.length === 0)
+        throw new Error("--steps is required: at least one template.");
+    return client.post("/api/v1/emails/sequences", body);
+}));
+withSequenceSettingFlags(sequences
+    .command("update <id>")
+    .description("Change a sequence (PATCH /emails/sequences/:id): name, steps, sender, send window, stop rules, enrollment switches. The type cannot change. While people are in it, the steps they already received cannot be changed, removed or reordered (409 sequence_steps_in_use); later steps change and new ones append")
+    .option("--name <name>", "new name")
+    .option("--description <text>", "description")
+    .option("--steps <steps>", "the whole step list, in order (replaces the current steps): templateId:days,... or a JSON array")
+    .option("--json <json>", "full JSON body, merged over the flags")).action(run(async (client, id, opts) => {
+    const body = sequenceSettingsBody(opts);
+    if (opts.name !== undefined)
+        body.name = opts.name;
+    if (opts.description !== undefined)
+        body.description = opts.description;
+    if (opts.steps !== undefined)
+        body.steps = sequenceStepsArg(opts.steps);
+    if (opts.json !== undefined)
+        Object.assign(body, jsonArg(opts.json, "--json"));
+    if (Object.keys(body).length === 0)
+        throw new Error("Nothing to change: pass at least one flag.");
+    return client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, body);
+}));
+sequences
+    .command("on <id>")
+    .description("Turn a sequence On: its runs continue from where they are")
+    .action(run(async (client, id) => client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, { isActive: true })));
+sequences
+    .command("off <id>")
+    .description("Turn a sequence Off: every run stays where it is, nothing sends, until it is turned On again")
+    .action(run(async (client, id) => client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, { isActive: false })));
+sequences
+    .command("archive <id>")
+    .description("Archive a sequence: Off and hidden from lists (see `sequences list --archived`)")
+    .option("--restore", "bring an archived sequence back (stays Off until turned On)")
+    .action(run(async (client, id, opts) => client.patch(`/api/v1/emails/sequences/${uuidArg(id, "id")}`, { archived: !opts.restore })));
+sequences
+    .command("check <id> <contactIds...>")
+    .description("Check contacts BEFORE enrolling them (POST /emails/sequences/:id/preflight, up to 500): total, eligible, skipped, errors (blockers: Off, archived, a missing template, an unverified domain; any blocker makes nobody eligible), warnings, contacts [{contactId, eligible, reasons}]. Nothing is written")
+    .action(run(async (client, id, contactIds) => client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/preflight`, { contactIds: sequenceContactIds(contactIds) })));
+sequences
+    .command("senders <channel>")
+    .description("Who can be a sequence's sender (GET /emails/sequences/senders), for email or sms: every active member who accepted their invite; sms lists each one's assigned line (an SMS sequence needs one), email each one's address")
+    .action(run(async (client, channel) => {
+    if (channel !== "email" && channel !== "sms")
+        throw new Error("channel must be email or sms.");
+    return client.get(`/api/v1/emails/sequences/senders?channel=${channel}`);
+}));
+sequences
+    .command("pick-list <id>")
+    .description("Who of a saved list goes into the sequence next (POST /emails/sequences/:id/pick-from-list): the server walks the list in a stable order, leaves out whoever is already in, checks the rest, and returns up to --limit eligible contacts plus a cursor. Enroll the ids, then call again with --cursor until exhausted. Nothing is written")
+    .option("--smart-view <id>", "the Smart View to pick from (one of --smart-view / --smart-list)")
+    .option("--smart-list <id>", "the Smart List to pick from")
+    .option("--limit <n>", "eligible contacts to return, 1-500 (default 500)")
+    .option("--cursor <cursor>", "where to continue, from the previous call")
+    .action(run(async (client, id, opts) => {
+    if (!opts.smartView && !opts.smartList)
+        throw new Error("Pass --smart-view or --smart-list.");
+    if (opts.smartView && opts.smartList)
+        throw new Error("Pass one of --smart-view or --smart-list.");
+    const body = {};
+    if (opts.smartView)
+        body.smartViewId = uuidArg(opts.smartView, "--smart-view");
+    if (opts.smartList)
+        body.smartListId = uuidArg(opts.smartList, "--smart-list");
+    if (opts.limit !== undefined) {
+        const n = Number(opts.limit);
+        if (!Number.isInteger(n) || n < 1 || n > 500)
+            throw new Error("--limit must be 1 to 500.");
+        body.limit = n;
+    }
+    if (opts.cursor !== undefined)
+        body.cursor = opts.cursor;
+    return client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/pick-from-list`, body);
+}));
+sequences
+    .command("enroll <id> <contactIds...>")
+    .description("Enroll contacts (POST /emails/sequences/:id/enroll, up to 500; the sequence must be On and not archived): skips anyone with no address for the channel, opted out, or already in it; with re-enrollment allowed, an ENDED run starts over (a live or paused one never restarts). Returns enrolled, skipped, duplicates, total, skippedDetails")
+    .action(run(async (client, id, contactIds) => client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/enroll`, { contactIds: sequenceContactIds(contactIds) })));
+sequences
+    .command("unenroll <id> <contactId>")
+    .description("Remove a contact from a sequence (POST /emails/sequences/:id/unenroll): their live, paused or failed run ends (status cancelled, endedReason removed). Returns contactId, unenrolled, currentStatus")
+    .action(run(async (client, id, contactId) => client.post(`/api/v1/emails/sequences/${uuidArg(id, "id")}/unenroll`, { contactId: uuidArg(contactId, "contactId") })));
+const SEQUENCE_RUN_STATUSES = ["active", "paused", "completed", "failed", "cancelled", "unsubscribed"];
+sequences
+    .command("people <id>")
+    .description("Who is in a sequence (GET /emails/sequences/:id/enrollments), newest run first: contact, currentStep, nextSendAt, engagement, status (active | paused | completed | failed | cancelled | unsubscribed) and endedReason (completed | replied | meeting | opted_out | bounced | deal_closed | removed; null while live). A paused run with no endedReason is live: it resumes when the sequence is turned On")
+    .option("--status <status>", "active | paused | completed | failed | cancelled | unsubscribed")
+    .option("--all-active", "every live run in one answer (all_active=true): no paging, no engagement; refused past 5,000")
+    .option("--page <n>", "page number")
+    .option("--limit <n>", "results per page (per_page, max 200)")
+    .action(run(async (client, id, opts) => {
+    const params = {};
+    if (opts.status !== undefined) {
+        if (!SEQUENCE_RUN_STATUSES.includes(opts.status))
+            throw new Error(`--status must be one of ${SEQUENCE_RUN_STATUSES.join(", ")}.`);
+        params.status = opts.status;
+    }
+    if (opts.allActive)
+        params.all_active = "true";
+    if (opts.page !== undefined)
+        params.page = opts.page;
+    if (opts.limit !== undefined)
+        params.per_page = opts.limit;
+    return client.get(`/api/v1/emails/sequences/${uuidArg(id, "id")}/enrollments${buildQuery(params)}`);
+}));
+sequences
+    .command("stats <id>")
+    .description("Performance of a sequence (GET /emails/sequences/:id/stats): totals {enrolled (runs started, all time), contacts (people in it now), sent, opened, clicked, loggedSends, openRate, clickRate}, perStep and removedSteps")
+    .action(run(async (client, id) => client.get(`/api/v1/emails/sequences/${uuidArg(id, "id")}/stats`)));
+/** contact ids as given, or a comma-separated list in one argument; 1 to 500 UUIDs */
+function sequenceContactIds(args) {
+    const ids = args.flatMap((a) => a.split(",")).map((s) => s.trim()).filter(Boolean);
+    if (ids.length === 0)
+        throw new Error("Pass at least one contact id.");
+    if (ids.length > 500)
+        throw new Error("At most 500 contacts per call.");
+    return ids.map((id) => uuidArg(id, "contactId"));
+}
 const dripEnrollments = program.command("drip-enrollments").description("Drip enrollment recovery");
 dripEnrollments
     .command("cancel-barrier <id>")
@@ -2413,6 +2682,90 @@ function onOffArg(raw, flag) {
         return false;
     throw new Error(`${flag} takes on or off (got '${raw}').`);
 }
+/** the two lines a workspace records calls on: its Twilio lines (settings.recording) and its iPhone line (settings.projectBlueRecording) */
+const RECORDING_KEY = { twilio: "recording", iphone: "projectBlueRecording" };
+const isDisclosureOn = (v) => v === "inbound" || v === "outbound" || v === "both";
+/** what a stored policy MEANS, read the way the server reads it: the old shape { enabled, consentGreeting } is outbound
+ *  recording with the disclosure on whenever a wording is set; enabled stays beside outbound as the old name of the switch */
+export function effectiveRecordingPolicy(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    const greeting = typeof r.consentGreeting === "string" ? r.consentGreeting.trim() : "";
+    const newShape = typeof r.inbound === "boolean" || typeof r.outbound === "boolean" || (r.disclosure !== undefined && r.disclosure !== null);
+    if (newShape) {
+        const d = (r.disclosure && typeof r.disclosure === "object" ? r.disclosure : {});
+        const outbound = typeof r.outbound === "boolean" ? r.outbound : r.enabled === true;
+        return { inbound: r.inbound === true, outbound, disclosure: { enabled: d.enabled === true, on: isDisclosureOn(d.on) ? d.on : "outbound" }, consentGreeting: greeting, enabled: outbound };
+    }
+    const outbound = r.enabled === true;
+    return { inbound: false, outbound, disclosure: { enabled: outbound && greeting.length > 0, on: "outbound" }, consentGreeting: greeting, enabled: outbound };
+}
+/** the iPhone line has no inbound calls: what its policy does there, the way the server applies it */
+export function iphoneRecordingDomain(policy) {
+    return { ...policy, inbound: false, disclosure: policy.disclosure.on === "inbound" ? { enabled: false, on: "outbound" } : { enabled: policy.disclosure.enabled, on: "outbound" } };
+}
+dialer
+    .command("recording")
+    .description("Show the workspace's call recording policy for both kinds of line (GET /settings). twilio = its Twilio lines: always an object, with everything off when the workspace never set it. Needs a key whose creator may view settings; without it the command fails instead of showing a policy. iphone = the iPhone line's OWN policy (outbound only); null = none was written, and the iPhone line then follows the Twilio lines' policy without its inbound part. Each object is the policy as it is APPLIED: inbound, outbound, disclosure { enabled, on: inbound | outbound | both }, consentGreeting (what is said; empty = the default sentence) and enabled (the OLD name of the outbound switch: the same value as outbound). A workspace that never saved the new shape is read the way the server reads its old one: outbound recording with the disclosure on whenever a wording is set")
+    .action(run(async (client) => {
+    const result = (await client.get("/api/v1/settings"));
+    const raw = result?.data ?? {};
+    const twilio = effectiveRecordingPolicy(raw[RECORDING_KEY.twilio]);
+    // a key whose creator may not view settings gets a short answer WITHOUT the policy: that is "not visible",
+    // never "not configured" (the full answer always carries the Twilio policy)
+    if (!twilio)
+        throw new Error("The call recording policy is not visible to this API key: its creator needs permission to view settings. Nothing can be said about whether calls are recorded.");
+    const iphone = effectiveRecordingPolicy(raw[RECORDING_KEY.iphone]);
+    return { data: { twilio, iphone: iphone ? iphoneRecordingDomain(iphone) : null } };
+}));
+dialer
+    .command("set-recording")
+    .description("Change the workspace's call recording policy (admin: settings scope). Send only what changes; the rest stays. The workspace is responsible for consent where it operates. Example: conduyt dialer set-recording --inbound on --outbound on --disclosure on --disclosure-on inbound")
+    .option("--line <line>", "which line's policy: twilio (default) or iphone")
+    .option("--inbound <on|off>", "record calls the team receives (Twilio lines only)")
+    .option("--outbound <on|off>", "record calls the team makes, including Smart Dialing")
+    .option("--enabled <on|off>", "the OLD name of --outbound, accepted for older callers and sent as --outbound (when both are sent, --outbound decides); nothing else changes with it")
+    .option("--disclosure <on|off>", "play a recording disclosure (send together with --disclosure-on)")
+    .option("--disclosure-on <calls>", "which calls the disclosure plays on: inbound | outbound | both (send together with --disclosure). On the iPhone line: inbound is refused, both is saved as outbound")
+    .option("--greeting <text>", "what is said (500 characters at most; an empty string = the default sentence)")
+    .action(run(async (client, opts) => {
+    const line = opts.line ?? "twilio";
+    if (line !== "twilio" && line !== "iphone")
+        throw new Error("--line must be twilio or iphone.");
+    if ([opts.inbound, opts.outbound, opts.enabled, opts.disclosure, opts.disclosureOn, opts.greeting].every((v) => v === undefined)) {
+        throw new Error("Nothing to change: pass at least one of --inbound, --outbound, --disclosure with --disclosure-on, --greeting.");
+    }
+    if ((opts.disclosure === undefined) !== (opts.disclosureOn === undefined)) {
+        throw new Error("--disclosure and --disclosure-on are sent together: the disclosure is one setting (whether it plays, and on which calls).");
+    }
+    if (line === "iphone" && opts.inbound !== undefined)
+        throw new Error("The iPhone line records outbound calls only: --inbound is not a setting of that line.");
+    const policy = {};
+    if (opts.inbound !== undefined)
+        policy.inbound = onOffArg(opts.inbound, "--inbound");
+    // (Codex r4) the old name is the outbound switch and nothing else: sent AS outbound, never as enabled (the server
+    // gives an enabled-only write over a policy saved in the old shape its old whole meaning, disclosure included)
+    if (opts.outbound !== undefined)
+        policy.outbound = onOffArg(opts.outbound, "--outbound");
+    else if (opts.enabled !== undefined)
+        policy.outbound = onOffArg(opts.enabled, "--enabled");
+    if (opts.disclosure !== undefined && opts.disclosureOn !== undefined) {
+        if (!["inbound", "outbound", "both"].includes(opts.disclosureOn))
+            throw new Error("--disclosure-on must be one of: inbound, outbound, both.");
+        // the iPhone line has no inbound calls: a disclosure on inbound only would never play, so it is refused here
+        // instead of saved as if it were on; both is what the line does on its outbound calls
+        if (line === "iphone" && opts.disclosureOn === "inbound")
+            throw new Error("The iPhone line has outbound calls only: a disclosure on inbound calls would never play. Use --disclosure-on outbound.");
+        policy.disclosure = { enabled: onOffArg(opts.disclosure, "--disclosure"), on: line === "iphone" && opts.disclosureOn === "both" ? "outbound" : opts.disclosureOn };
+    }
+    if (opts.greeting !== undefined) {
+        if (opts.greeting.trim().length > 500)
+            throw new Error("--greeting may be at most 500 characters.");
+        policy.consentGreeting = opts.greeting.trim();
+    }
+    return patchGeneralSettings(client, { [RECORDING_KEY[line]]: policy });
+}));
 dialer
     .command("settings")
     .description("Show the account's Smart Dialing policy (GET /dialer/settings, dialer scope): autoAdvanceEnabled, pauseSeconds, advanceOn (disposition | timer), openLeadOnDial (the lead's record opens as each Smart Dialing call goes out), smartDialCallerId (local_presence = an area-code match from the number pool, the rep's own line when no pool exists; did = always the rep's own line), plus localPresenceConfigured.")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt",
-  "version": "1.56.0",
+  "version": "1.58.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",