conduyt 1.65.0 → 1.67.0

package/README.md

@@ -32,7 +32,7 @@ The saved config lives at `~/.conduyt/config.json` and is written owner-only (`c
 ```bash
 conduyt whoami                          # show the authenticated user
 conduyt contacts list --limit 25        # list contacts (supports --cursor, --query)
-conduyt contacts get <id>               # fetch one contact (carries `revision`)
+conduyt contacts get <id>               # fetch one contact (carries `revision` and `hasOutboundSms`, a proven send only)
 conduyt contacts update <id> --first Ann --expected-revision <n>   # PATCH; a contact changed since revision n is refused: 409 contact_changed, exit 1, code and current revision printed
 conduyt contacts collaborators add <contactId> <userId> [--expected-revision <n>]      # POST /contacts/{id}/collaborators; prints { added, revision }
 conduyt contacts collaborators remove <contactId> <userId> [--expected-revision <n>]   # DELETE with a body; prints { removed, revision }; 404 when not a collaborator
@@ -44,6 +44,8 @@ conduyt notifications list [--page n] [--per-page 1-200]   # prints { data, meta
 conduyt deals list --pipeline <id>      # list deals
 conduyt deals list --health-summary --pipeline <id>   # Pipeline health strip for the filtered set (totalOpenDeals, atRiskValue, checks[]); add --health-check stale --health-limit 20 for one check's deals, --health-cursor <nextCursor> to page, --health-rows-only for just the page
 conduyt deals health --pipeline <id> --check needs_action   # GET /deals/inspection: the six checks over open deals; --check adds its deals, --cursor/--offset pages
+conduyt deals health-fix <dealId> --check stale --expected-updated-at <iso> --stage-id <uuid>   # Pipeline health quick fix (PATCH /deals/{id} with checkOrigin): stale = --stage-id, unassigned = --assigned, missing_close_date = --close-date, missing_contact = --contact; 409 deal_changed / deal_check_cleared and 400 health_fix_mismatch exit 1 verbatim, never retried
+conduyt deals health-next-action <dealId> --check needs_action --expected-updated-at <iso> --title "Call back" --idempotency-key <key>   # "Set next action" (POST /tasks with checkOrigin): one non-done quick-fix task per deal, 409 deal_has_next_action / deal_changed / deal_check_cleared exit 1 verbatim
 conduyt deals card-fields set value,contact,custom:next_contact_at   # the kanban card fields (1-8, built-ins or custom:<fieldKey>); `card-fields get` reads them
 conduyt pipelines stage-rules set <pipelineId> <stageId> --required-fields contactId,custom:loan_amount --required-documents 2 [--lost-reason-allow-other true]   # what a deal needs to enter the stage; other stages untouched; `stage-rules get [pipelineId] [stageId]` reads
 conduyt deals bulk-update --file updates.json   # update up to 100 deals at once ([{id, stageId, value, ...}]); per-item results, exit 1 if any failed
@@ -76,15 +78,18 @@ conduyt whatsapp connect <senderSid>    # connect a sender (verified with Twilio
 conduyt whatsapp templates              # approved / pending / rejected templates with their {{n}} placeholders
 conduyt dialer voice-drop --contact <id> [--recording "Missed you"] [--if-human play]   # a call that plays a Voicemail Drop recording to a machine
 conduyt messages send-sms --contact <id> --transport whatsapp --whatsapp-template HX… --whatsapp-variables '{"1":"Alex"}' --body "…"
+conduyt messages check --channel sms --body "…" [--context first|conversation] [--body-file draft.txt]   # grade a DRAFT before sending (score, grade, flagged words with safer alternatives, Unicode code-point offsets); educates, never blocks, nothing stored or sent; 20 per minute; 400 / 403 / 413 / 429 exit 1 with the code
 conduyt privacy export <id>             # GDPR data-portability export (owner/admin)
 conduyt privacy forget <id> --confirm FORGET  # GDPR erasure — IRREVERSIBLE, owner only
 conduyt reply-capture status            # inbound reply capture: state, DNS records, provider health
 conduyt reply-capture setup             # create the receiving subdomain (--domain optional)
 conduyt reply-capture verify            # promote it to live once DNS is confirmed
 conduyt reply-capture remove --confirm REMOVE  # remove capture — replies to already-sent email are lost
+conduyt integrations wordpress-forms status   # is any intake address active, and how many ({ hasActive, activeCount }; count only, read-only, integrations scope)
 conduyt integrations wordpress-forms list    # WordPress form intake addresses: full URL of every active one, received counts
 conduyt integrations wordpress-forms create --name "Contact page" --default-tag "Website lead"   # prints the full URL
 conduyt integrations wordpress-forms revoke <id>   # the address answers 404 from now on; the row is kept
+conduyt lifecycle set-booking-creates-own-card --enable   # a booking creates its own card owned by the host instead of reusing the contact's open intake card (--disable = default; `lifecycle settings` shows bookingCreatesOwnCard)
 conduyt api GET /api/v1/companies       # raw authenticated request (escape hatch)
 conduyt config show                     # show resolved config (key masked)
 ```
@@ -93,6 +98,24 @@ Pass `--input '{"...":"..."}'` to `insights` and `--body '{"...":"..."}'` to `ap
 
 All output is JSON, ready to pipe into `jq`.
 
+## Error output grammar
+
+A refused call (HTTP 4xx/5xx) prints one line on stderr and exits 1:
+
+```
+Error: Conduyt API <status>: <server message>[ [Retry-After: <N>s]][ <details>]
+```
+
+`[Retry-After: Ns]` appears only when the server sent the header (shown, never acted on: nothing is retried). `<details>` appears
+only when the body had more than `error`: it is ONE JSON object and the FINAL token. To extract it, try each `{` from the left
+until the rest of the line parses as JSON (a server message may itself contain a brace). Scalars (`code`, revision) come
+first, nested objects whole; `HealthFixRefusal.row` is always whole, any other nested object too large for the bound is left
+out and named in `_omitted`. Every HTTP refusal takes this path (JSON calls, text exports and streams alike). The settings-conflict commands merge their hint and the current settings INTO that final object (`{...details, hint, current}`), never after it. Example:
+
+```
+Error: Conduyt API 503: Contact merge in progress [Retry-After: 5s] {"code":"merge_in_progress"}
+```
+
 ## License
 
 MIT

package/dist/action-config-typos.js

@@ -0,0 +1,78 @@
+/**
+ * Local typo guard for automation action configs (card ownership per lane, Codex r1/r2). The server validator is the authority
+ * and there the option names are not enforced yet, so a typoed `laneSoruce` on assign_to_user would silently assign the run's
+ * deal instead of the lane card. Only the options below are known here.
+ *
+ * Traversal rule: ONLY the real action positions of the graph are visited, exactly as the graph is shaped: a v1 `actions`
+ * array's elements `{type, config}`, and a v2 graph's `nodes[].action` `{type, config}`. For each action of a known type the
+ * IMMEDIATE keys of `config` are checked; the config VALUES are opaque and never descended into (a webhook payload may hold any
+ * object, including one shaped like an action), and nothing outside those positions (request metadata, other node fields) is
+ * scanned. A key that is not a known option but is a case-insensitive match or ONE edit (substitution, insertion, deletion or
+ * adjacent transposition) from one is refused; keys further away, and every other action type, pass through.
+ * Source of the names: lib/automation-action-registry.ts in the app (assign_to_user, create_deal, close_other_open_deals).
+ */
+const KNOWN_ACTION_OPTIONS = {
+    assign_to_user: ["runWindow", "mode", "userId", "userIds", "groupId", "target", "applyTo", "overwriteExisting", "laneSource", "lanePipelineId", "laneStageId"],
+    create_deal: ["pipelineId", "stageId", "dealName", "dealValue", "allowDuplicates", "status", "source", "assignedTo", "leaveUnassigned"],
+    close_other_open_deals: ["lostReason"],
+};
+/** Damerau-Levenshtein (optimal string alignment) distance, case-insensitive */
+function distance(a, b) {
+    const x = a.toLowerCase(), y = b.toLowerCase();
+    const d = Array.from({ length: x.length + 1 }, (_, i) => [i, ...Array(y.length).fill(0)]);
+    for (let j = 1; j <= y.length; j++)
+        d[0][j] = j;
+    for (let i = 1; i <= x.length; i++) {
+        for (let j = 1; j <= y.length; j++) {
+            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (x[i - 1] === y[j - 1] ? 0 : 1));
+            if (i > 1 && j > 1 && x[i - 1] === y[j - 2] && x[i - 2] === y[j - 1])
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+        }
+    }
+    return d[x.length][y.length];
+}
+const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function checkAction(action) {
+    if (!isObject(action) || typeof action.type !== "string" || !isObject(action.config))
+        return null;
+    const known = KNOWN_ACTION_OPTIONS[action.type];
+    if (!known)
+        return null;
+    for (const key of Object.keys(action.config)) {
+        if (known.includes(key))
+            continue;
+        const near = known.find((k) => distance(key, k) <= 1);
+        if (near)
+            return { actionType: action.type, key, suggestion: near };
+    }
+    return null;
+}
+/** The first misspelled option key in an actions graph (v1 array of {type, config}, or v2 { nodes: [{ action: {type, config} }] }), or null */
+export function findActionConfigTypo(graph) {
+    if (Array.isArray(graph)) {
+        for (const action of graph) {
+            const t = checkAction(action);
+            if (t)
+                return t;
+        }
+        return null;
+    }
+    if (isObject(graph) && Array.isArray(graph.nodes)) {
+        for (const node of graph.nodes) {
+            const t = isObject(node) ? checkAction(node.action) : null;
+            if (t)
+                return t;
+        }
+    }
+    return null;
+}
+/** The refusal text; the details object is the final token */
+export function actionConfigTypoMessage(t) {
+    return `Unknown option "${t.key}" in ${t.actionType} config: did you mean "${t.suggestion}"? Nothing was sent. ${JSON.stringify(t)}`;
+}
+/** Throws (a plain Error) when the graph carries a misspelled option */
+export function assertNoActionConfigTypo(graph) {
+    const t = findActionConfigTypo(graph);
+    if (t)
+        throw new Error(actionConfigTypoMessage(t));
+}

package/dist/client.js

@@ -7,6 +7,98 @@ function ambiguousTimeout(err, method, path, timeoutMs, what) {
     }
     return err;
 }
+/** Room for the nested objects of an error body (a 409 contact_changed's `contact`, a stage-requirements list). */
+const ERROR_DETAILS_BOUND = 1000;
+/** Error-body keys that are the actionable state itself and are always rendered WHOLE: HealthFixRefusal.row (the deal's
+ *  current health row, which a caller needs to choose again). */
+const ALWAYS_WHOLE_KEYS = new Set(["row"]);
+/** Bounded scheme for a refusal's error LISTS (the automation write refusals: AutomationActionConfigKeyError.errors, the 422
+ *  AutomationPreflightRefusal.data { message, errors[], warnings[] }) when they do not fit ERROR_DETAILS_BOUND: keep the first
+ *  MAX_LISTED_ERRORS entries (warnings: MAX_LISTED_WARNINGS) with every string field capped at MAX_FIELD_CHARS, and close the list with
+ *  { "_more": K } for the K entries dropped, so each kept error still carries its code, nodeId, field and suggestion text. */
+const MAX_LISTED_ERRORS = 25;
+const MAX_LISTED_WARNINGS = 10;
+const MAX_FIELD_CHARS = 400;
+const capText = (s) => (s.length > MAX_FIELD_CHARS ? s.slice(0, MAX_FIELD_CHARS) + "...[shortened]" : s);
+const capEntry = (e) => {
+    if (typeof e === "string")
+        return capText(e);
+    if (e && typeof e === "object" && !Array.isArray(e))
+        return Object.fromEntries(Object.entries(e).map(([k, v]) => [k, typeof v === "string" ? capText(v) : v]));
+    return e;
+};
+const capList = (list, max) => [...list.slice(0, max).map(capEntry), ...(list.length > max ? [{ _more: list.length - max }] : [])];
+function compactRefusalList(key, value) {
+    if (key === "errors" && Array.isArray(value))
+        return capList(value, MAX_LISTED_ERRORS);
+    if (key === "data" && value && typeof value === "object" && !Array.isArray(value)) {
+        const d = value;
+        const out = {};
+        for (const [k, v] of Object.entries(d)) {
+            if (k === "message" && typeof v === "string")
+                out[k] = capText(v);
+            else if (k === "errors" && Array.isArray(v))
+                out[k] = capList(v, MAX_LISTED_ERRORS);
+            else if (k === "warnings" && Array.isArray(v))
+                out[k] = capList(v, MAX_LISTED_WARNINGS);
+            else if (v === null || typeof v !== "object")
+                out[k] = v;
+        }
+        return out;
+    }
+    return undefined;
+}
+/** Everything but `error` as ONE valid JSON object: scalars first (a very long string is shortened inside its quotes), then
+ *  nested objects whole while they fit ERROR_DETAILS_BOUND, plus ALWAYS_WHOLE_KEYS; one that does not fit is left out and
+ *  named in `_omitted`. JSON is never cut mid-object. */
+export function renderErrorDetails(body) {
+    const entries = Object.entries(body).filter(([k]) => k !== "error");
+    if (entries.length === 0)
+        return "";
+    const isScalar = (v) => v === null || typeof v !== "object";
+    const out = {};
+    for (const [k, v] of entries.filter(([, v]) => isScalar(v)))
+        out[k] = typeof v === "string" && v.length > ERROR_DETAILS_BOUND ? v.slice(0, ERROR_DETAILS_BOUND) + "...[shortened]" : v;
+    const omitted = [];
+    for (const [k, v] of entries.filter(([, v]) => !isScalar(v))) {
+        // an EMPTY list / object (the import refusal's `warnings: []`) always fits: it costs two characters and is never "omitted"
+        if (ALWAYS_WHOLE_KEYS.has(k) || JSON.stringify(v).length <= 2 || JSON.stringify({ ...out, [k]: v }).length <= ERROR_DETAILS_BOUND)
+            out[k] = v;
+        else {
+            // a refusal's error list never vanishes into `_omitted`: it is kept in the bounded scheme above (codes and suggestions intact)
+            const compact = compactRefusalList(k, v);
+            if (compact !== undefined)
+                out[k] = compact;
+            else
+                omitted.push(k);
+        }
+    }
+    if (omitted.length > 0)
+        out._omitted = omitted;
+    return JSON.stringify(out);
+}
+/**
+ * The ONE place an HTTP refusal becomes an Error (request, postText and stream all use it). Grammar (stable):
+ * `Conduyt API <status>: <message>[ [Retry-After: <N>s]][ <details>]`; <details> is ONE JSON object and the FINAL token
+ * (renderErrorDetails). Retry-After is shown, never acted on. A structured body without `error` IS the details object.
+ */
+export function formatHttpError(res, text) {
+    const json = text ? safeParse(text) : null;
+    const ra = res.headers.get("retry-after");
+    const raN = ra === null || ra.trim() === "" ? NaN : Number(ra);
+    const raTag = Number.isFinite(raN) && raN >= 0 ? ` [Retry-After: ${raN}s]` : "";
+    const obj = json && typeof json === "object" && !Array.isArray(json) ? json : null;
+    if (obj && typeof obj.error === "string" && obj.error) {
+        const extras = renderErrorDetails(obj);
+        return new Error(`Conduyt API ${res.status}: ${obj.error}${raTag}${extras ? ` ${extras}` : ""}`);
+    }
+    // several endpoints answer the data a caller needs IN the error body (custom-field delete 409 valueCount / dependencyCount)
+    const extras = obj ? renderErrorDetails(obj) : "";
+    if (extras)
+        return new Error(`Conduyt API ${res.status}:${raTag} ${extras}`);
+    const plain = typeof json === "string" && json ? json.slice(0, 500) : "";
+    return new Error(`Conduyt API ${res.status}: ${plain || res.statusText || `HTTP ${res.status}`}${raTag}`);
+}
 export class ConduytClient {
     baseUrl;
     apiKey;
@@ -25,6 +117,7 @@ export class ConduytClient {
             res = await fetch(url, {
                 method,
                 headers: {
+                    ...(opts?.headers ?? {}),
                     Authorization: `Bearer ${this.apiKey}`,
                     "Content-Type": "application/json",
                 },
@@ -45,31 +138,7 @@ export class ConduytClient {
         }
         const json = text ? safeParse(text) : null;
         if (!res.ok) {
-            // Preserve structured non-2xx bodies: several endpoints return the data
-            // a caller needs to proceed IN the error body (e.g. custom-field delete
-            // 409 carries valueCount/dependencyCount for the --confirm flow).
-            // Reducing those to statusText would strand the user.
-            const structured = json && typeof json === "object" && !json.error
-                ? JSON.stringify(json)
-                : null;
-            let msg = json?.error || structured || res.statusText || `HTTP ${res.status}`;
-            // Bodies with BOTH an error message and structured context (e.g. the
-            // STAGE_REQUIREMENTS 422 carries lostReasonOptions) keep the context —
-            // same principle as `structured` above, bounded against huge bodies.
-            if (json && typeof json === "object" && json.error) {
-                // Scalars first (code, revision), nested objects last: a 409 contact_changed also carries the whole current
-                // `contact`, and the bound below may cut that, never the code or the current revision.
-                const isScalar = (v) => v === null || typeof v !== "object";
-                const entries = Object.entries(json).filter(([k]) => k !== "error");
-                const extras = Object.fromEntries([
-                    ...entries.filter(([, v]) => isScalar(v)),
-                    ...entries.filter(([, v]) => !isScalar(v)),
-                ]);
-                if (Object.keys(extras).length > 0) {
-                    msg = `${msg} ${JSON.stringify(extras).slice(0, 1000)}`;
-                }
-            }
-            throw new Error(`Conduyt API ${res.status}: ${msg}`);
+            throw formatHttpError(res, text);
         }
         return json;
     }
@@ -98,14 +167,8 @@ export class ConduytClient {
             body: body === undefined ? undefined : JSON.stringify(body),
         });
         const text = await res.text();
-        if (!res.ok) {
-            let msg = text.slice(0, 500);
-            try {
-                msg = JSON.parse(text).error ?? msg;
-            }
-            catch { /* keep the raw text */ }
-            throw new Error(`Conduyt API ${res.status}: ${msg}`);
-        }
+        if (!res.ok)
+            throw formatHttpError(res, text);
         return { text, filename: res.headers.get("x-report-filename"), contentType: res.headers.get("content-type") };
     }
     // Stream `ai chat`'s text/event-stream response to stdout as clean answer
@@ -127,10 +190,7 @@ export class ConduytClient {
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
         if (!res.ok || !res.body) {
-            const text = await res.text();
-            const json = text ? safeParse(text) : null;
-            const msg = json?.error || res.statusText || `HTTP ${res.status}`;
-            throw new Error(`Conduyt API ${res.status}: ${msg}`);
+            throw formatHttpError(res, await res.text());
         }
         const reader = res.body.getReader();
         const decoder = new TextDecoder();

package/dist/index.js

@@ -79,7 +79,7 @@ contacts
     .action(run(async (client, opts) => client.get(`/api/v1/contacts${buildQuery({ limit: opts.limit, cursor: opts.cursor, query: opts.query, master_status: opts.masterStatus, exclude_master_status: opts.excludeMasterStatus })}`)));
 contacts
     .command("get <id>")
-    .description("Get a single contact by id (includes `revision`: pass it as --expected-revision on `contacts update` / `contacts collaborators`)")
+    .description("Get a single contact by id (includes `revision`: pass it as --expected-revision on `contacts update` / `contacts collaborators`; `hasOutboundSms` is true when the workspace has ever PROVABLY texted the contact: a proven send only, not a draft, a queued row or a pre-send failure; use it to pick `messages check --context`: false = first, true = conversation)")
     .action(run(async (client, id) => client.get(`/api/v1/contacts/${encodeURIComponent(id)}`)));
 contacts
     .command("create")
@@ -536,6 +536,73 @@ deals
     const qs = usp.toString();
     return client.get(`/api/v1/deals/inspection${qs ? `?${qs}` : ""}`);
 }));
+const HEALTH_FIX_REFUSALS = "Error line grammar: `Error: Conduyt API <status>: <message>[ [Retry-After: Ns]][ <one JSON object, the final token>]` (README, Error output grammar). Refusals exit 1 with the server's status, message and code printed verbatim, sent once (never retried): 409 deal_changed (the deal is no longer at --expected-updated-at; the error carries updatedAt and the deal's current health row: read it and choose again against row.updatedAt), 409 deal_check_cleared (the deal no longer fails that check), 400 health_fix_mismatch, 404";
+deals
+    .command("health-fix <id>")
+    .description(`Pipeline health QUICK FIX for a deal row (PATCH /deals/{id} with checkOrigin). Send the check the row came from, --expected-updated-at (the deal's updatedAt as the health row carried it, REQUIRED) and ONLY that check's fix: stale = --stage-id (+ --expected-stage-id), unassigned = --assigned, missing_close_date = --close-date, missing_contact = --contact. Anything else is refused 400 health_fix_mismatch and nothing is read or written. For high_value_idle / needs_action use \`deals health-next-action\`. ${HEALTH_FIX_REFUSALS}; an uncoded 409 is a stage move by another writer, a stale --expected-stage-id or an in-flight publication`)
+    .requiredOption("--check <check>", "stale | unassigned | missing_close_date | missing_contact")
+    .requiredOption("--expected-updated-at <iso>", "the deal's updatedAt as the health row carried it (PipelineHealthDeal.updatedAt)")
+    .option("--stage-id <uuid>", "stale: the stage UUID to move the deal to")
+    .option("--expected-stage-id <uuid>", "stale: the stage the move was chosen against; 409 (nothing written) when the deal is no longer in it")
+    .option("--assigned <uuid>", "unassigned: the user (owner) UUID to assign")
+    .option("--close-date <date>", "missing_close_date: the expected close date (ISO 8601)")
+    .option("--contact <uuid>", "missing_contact: the contact UUID to link")
+    .action(run(async (client, id, opts) => {
+    const dealId = uuidOf(id, "deal id");
+    if (!["stale", "unassigned", "missing_close_date", "missing_contact"].includes(opts.check))
+        throw new Error("--check must be stale, unassigned, missing_close_date or missing_contact (for high_value_idle / needs_action use `deals health-next-action`).");
+    rejectBlankFlags([["--close-date", opts.closeDate]]);
+    const body = { checkOrigin: opts.check, expectedUpdatedAt: isoDate(opts.expectedUpdatedAt, "--expected-updated-at") };
+    if (opts.stageId !== undefined)
+        body.stageId = uuidOf(opts.stageId, "--stage-id");
+    if (opts.expectedStageId !== undefined)
+        body.expectedStageId = uuidOf(opts.expectedStageId, "--expected-stage-id");
+    if (opts.assigned !== undefined)
+        body.assignedTo = uuidOf(opts.assigned, "--assigned");
+    if (opts.closeDate !== undefined)
+        body.expectedCloseDate = opts.closeDate;
+    if (opts.contact !== undefined)
+        body.contactId = uuidOf(opts.contact, "--contact");
+    return client.patch(`/api/v1/deals/${encodeURIComponent(dealId)}`, body);
+}));
+deals
+    .command("health-next-action <id>")
+    .description(`Pipeline health QUICK FIX "Set next action" (POST /tasks with checkOrigin): creates a follow-up task on deal <id> from a High-value idle or Needs next action row. The task is created only while, under the deal's next-action lock, the deal is still at --expected-updated-at, still has no next action and still fails the check. Pass --idempotency-key (1-255 printable ASCII) so a retry after a lost response replays the first task; reuse it ONLY for the same request. The database allows at most one non-done quick-fix task per deal (a second is refused 409 deal_has_next_action); ordinary tasks (\`tasks create\`) are unconstrained and may coexist with or race a quick fix. ${HEALTH_FIX_REFUSALS.replace("409 deal_check_cleared", "409 deal_has_next_action (This deal already has a next action booked.), 409 deal_check_cleared")}; also an uncoded 409 (the contact was merged or deleted mid-request: retry against the surviving record) and the idempotency 409 idempotency_key_spent / 503 idempotency_claim_held / idempotency_outcome_unknown (verify the outcome before using a new key)`)
+    .requiredOption("--check <check>", "high_value_idle | needs_action")
+    .requiredOption("--expected-updated-at <iso>", "the deal's updatedAt as the health row carried it (sent as expectedDealUpdatedAt)")
+    .requiredOption("--title <title>", "task title (1-500 chars)")
+    .option("--description <text>", "description (max 5000)")
+    .option("--due <date>", "due date: YYYY-MM-DD is stored as noon UTC that day; a date-time as given")
+    .option("--priority <priority>", "low|medium|high|urgent (default medium)")
+    .option("--status <status>", "todo|in_progress|done (default todo)")
+    .option("--assigned <id>", "assignee user UUID, or @me / @owner (assigning to someone else needs tasks.assign)")
+    .option("--contact <uuid>", "link to contact UUID")
+    .option("--idempotency-key <key>", "sent as the Idempotency-Key header")
+    .action(run(async (client, id, opts) => {
+    const dealId = uuidOf(id, "deal id");
+    if (!["high_value_idle", "needs_action"].includes(opts.check))
+        throw new Error("--check must be high_value_idle or needs_action (for the other checks use `deals health-fix`).");
+    if (opts.title.trim() === "" || opts.title.length > 500)
+        throw new Error("--title must be 1 to 500 characters.");
+    if (opts.description !== undefined && opts.description.length > 5000)
+        throw new Error("--description must be at most 5000 characters.");
+    if (opts.idempotencyKey !== undefined && !/^[!-~](?:[ -~]{0,253}[!-~])?$/.test(opts.idempotencyKey))
+        throw new Error("--idempotency-key must be 1-255 printable ASCII characters, not blank.");
+    const body = { checkOrigin: opts.check, dealId, expectedDealUpdatedAt: isoDate(opts.expectedUpdatedAt, "--expected-updated-at"), title: opts.title };
+    if (opts.description !== undefined)
+        body.description = opts.description;
+    if (opts.due !== undefined)
+        body.dueDate = opts.due;
+    if (opts.priority !== undefined)
+        body.priority = opts.priority;
+    if (opts.status !== undefined)
+        body.status = opts.status;
+    if (opts.assigned !== undefined)
+        body.assignedTo = opts.assigned;
+    if (opts.contact !== undefined)
+        body.contactId = uuidOf(opts.contact, "--contact");
+    return client.post("/api/v1/tasks", body, opts.idempotencyKey !== undefined ? { headers: { "Idempotency-Key": opts.idempotencyKey } } : undefined);
+}));
 // (BDA board 10-08) settings.dealCardFields: the fields on each kanban deal card, in order
 const cardFields = deals
     .command("card-fields")
@@ -1413,7 +1480,7 @@ tasks
 }));
 tasks
     .command("create")
-    .description("Create a task (--assigned accepts a user UUID, or the magic strings @me / @owner)")
+    .description("Create a task (--assigned accepts a user UUID, or the magic strings @me / @owner). This is the ORDINARY task route: ordinary tasks are unconstrained and may coexist with or race a Pipeline health quick-fix task; the database allows at most one non-done quick-fix task per deal (a second is refused 409 deal_has_next_action). Create the quick fix itself with `deals health-next-action`. A 409 without a code means the contact was merged or deleted mid-request: retry against the surviving record")
     .option("--title <title>", "task title (required)")
     .option("--description <text>", "description")
     .option("--status <status>", "todo|in_progress|done (default todo)")
@@ -1447,7 +1514,7 @@ tasks
 }));
 tasks
     .command("update <id>")
-    .description("Update a task (PATCH — only the fields you pass change)")
+    .description("Update a task (PATCH — only the fields you pass change). A 409 means nothing was written, printed verbatim with exit 1 and never retried: code deal_has_next_action (\"This deal already has a next action booked.\": re-opening or re-linking a quick-fix task would give the deal a second open one), or no code (the task changed while saving: read it again and retry)")
     .option("--title <title>", "task title")
     .option("--description <text>", "description")
     .option("--status <status>", "todo|in_progress|done")
@@ -1776,6 +1843,45 @@ messages
         Object.assign(body, jsonArg(opts.json, "--json"));
     return client.post("/api/v1/messages/sms/send", body);
 }));
+messages
+    .command("check")
+    .description("Grade a DRAFT text or email before sending (POST /messages/check): the same check the contact composers run as the rep types. Prints the route's data (the standard envelope is unwrapped): { score 0-100, grade A-F, verdict, vclass, hits, subjectHits, checks, sms (a text's chars / segments / unicode / perSeg; null for an email), context, notices (when present), engine { version, updatedAt } }. Each hit: { start, end, word, level (r likely blocked, a risky, y caution, n heads up), label, cat, why, alts (safer wording; some are advice rather than a swap), restricted (prohibited in US business texting: no rewording makes it deliverable), rule }. start / end are Unicode CODE-POINT offsets into the submitted text (the body for hits, the subject for subjectHits), end exclusive; an emoji counts as one, so [...text].slice(start, end) in JavaScript or text[start:end] in Python is the word (not a UTF-16 index). The check EDUCATES and never blocks: nothing is stored and nothing is sent; merge tokens such as {{contact.firstName}} are never flagged. --context template (default) grades a reusable message, first the first text to a contact, conversation a reply in an existing thread (the next engine release skips the opt-out and business-name checks for first / conversation; today every context scores the same); `contacts get <id>` carries hasOutboundSms to choose. Limits: body 10,000 characters, subject 300, request 48 KB; 20 checks per minute per account. Every refusal exits 1 with the status, the API's message and its code, sent once and never retried: 400 invalid_body, 403 forbidden (the key's member may view neither contacts nor email templates, or the key's scopes do not reach the route: needs the contacts, emails, sms or messages scope, a read-tier key too), 413 message_too_long / body_too_large, 429 rate_limited (Retry-After shown in the error text)")
+    .option("--channel <channel>", "sms | email (required)")
+    .option("--subject <text>", "email only (300 characters at most); refused on a text")
+    .option("--body <text>", "the draft text (10,000 characters at most)")
+    .option("--body-file <path>", "read the draft text from a file (for long text; not with --body)")
+    .option("--context <context>", "template (default) | first | conversation")
+    .option("--json <json>", "full JSON body { channel, subject?, body, context? }, merged over the flags")
+    .action(run(async (client, opts) => {
+    if (opts.body !== undefined && opts.bodyFile !== undefined)
+        throw new Error("Pass either --body or --body-file, not both.");
+    const body = {};
+    if (opts.channel !== undefined)
+        body.channel = opts.channel;
+    if (opts.subject !== undefined)
+        body.subject = opts.subject;
+    if (opts.body !== undefined)
+        body.body = opts.body;
+    if (opts.bodyFile !== undefined) {
+        if (opts.bodyFile.trim() === "")
+            throw new Error("--body-file must be a path (got an empty string).");
+        try {
+            body.body = readFileSync(opts.bodyFile, "utf8");
+        }
+        catch {
+            throw new Error(`--body-file could not be read: ${opts.bodyFile}`);
+        }
+    }
+    if (opts.context !== undefined)
+        body.context = opts.context;
+    if (opts.json !== undefined)
+        Object.assign(body, jsonArg(opts.json, "--json"));
+    if (body.channel === undefined)
+        throw new Error("--channel is required (sms | email).");
+    if (body.body === undefined)
+        throw new Error("The draft is required. Pass --body '<text>' or --body-file <path>.");
+    return client.post("/api/v1/messages/check", body);
+}));
 messages
     .command("conversations")
     .description("List conversation threads")
@@ -1975,6 +2081,8 @@ calendars
     return client.post("/api/v1/calendars", body);
 }));
 // ---- automations (the "AI builds a workflow" loop) ----
+// (#124, automation unknown keys / types) the refusal codes the write paths answer; printed by the client as `Conduyt API <status>: ...` with the details object last, never retried
+const AUTOMATION_KEY_REFUSALS_NOTE = " Unknown action keys are refused, never ignored: an action config key the action does not read (a typo such as `laneSoruce`) answers code unknown_action_config_key with the node, the key and, when one is close, a suggestion (\"Did you mean `laneSource`?\"); an action `type` no registry entry defines answers unknown_action_type (with \"Did you mean\" when a registered type is close). `automations import` answers 400, `automations validate` answers 200 with valid false and the `errors` list (nodeId, field, code, message), `automations publish` answers 422 (the preflight refusal wraps data.message, data.errors, data.warnings). Read the suggestion, fix the key and send again; a stored workflow is never refused on read.";
 const automations = program.command("automations").description("Build and run automations/workflows");
 automations
     .command("list")
@@ -2016,13 +2124,13 @@ automations
 }));
 automations
     .command("validate")
-    .description("Validate a workflow graph before saving. Provide the body via --json or --file (needs triggerEvent + graph). A delay node waits for a fixed duration by default; waitType \"until_field_date\" (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately).")
+    .description("Validate a workflow graph before saving. Provide the body via --json or --file (needs triggerEvent + graph). A delay node waits for a fixed duration by default; waitType \"until_field_date\" (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately). Card ownership per lane: assign_to_user config {userId | userIds (round robin) | groupId, target|applyTo: contact|deal|both, overwriteExisting, laneSource, lanePipelineId, laneStageId}: laneSource names a card lane (the Deal.source its Auto-Create step wrote, e.g. \"GSM\", max 500 chars) and makes the deal leg assign the contact's newest OPEN card from that lane (inside lanePipelineId when set) instead of the run's deal; when the contact has none and lanePipelineId is set, the card is created there (laneStageId, else the pipeline's first stage) already owned by the user; lanePipelineId or laneStageId without laneSource, or laneStageId without lanePipelineId, is refused; a lane never applies to an Assign-to-contact step. create_deal config {pipelineId (required), stageId, dealName, dealValue, allowDuplicates, status, source, assignedTo, leaveUnassigned}: leaveUnassigned true leaves the card unassigned when no assignee is set (default false: the card goes to the lead's owner). close_other_open_deals config {lostReason (required)}: closes the contact's OTHER open cards as lost with that reason, keeping the run's own card (each moves to its pipeline's lost stage with the usual stage-change effects; cards already won/lost, in the DPP Post-Close pipeline or in a pipeline with no lost stage are skipped; a re-run closes nothing twice); it needs the run's own deal, so use a deal trigger or a find_opportunity step first." + AUTOMATION_KEY_REFUSALS_NOTE)
     .option("--json <json>", "full request body as JSON")
     .option("--file <path>", "read the request body from a JSON file")
     .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). A sequence step is the action enroll_in_sequence with config {sequenceId, enrollAction: add (default) | remove}; add needs the sequence to allow automation enrollment. A delay node waits for a fixed duration by default; waitType \"until_field_date\" (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately).")
+    .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. A delay node waits for a fixed duration by default; waitType \"until_field_date\" (with fieldKey = a deal DATE / DATETIME custom field key and offsetHours = signed hours added to its date, default 0, e.g. 24 = a day after it) waits until that date stored on the deal, re-read at every wake (an empty or past value continues immediately). Card ownership per lane: assign_to_user config {userId | userIds (round robin) | groupId, target|applyTo: contact|deal|both, overwriteExisting, laneSource, lanePipelineId, laneStageId}: laneSource names a card lane (the Deal.source its Auto-Create step wrote, e.g. \"GSM\", max 500 chars) and makes the deal leg assign the contact's newest OPEN card from that lane (inside lanePipelineId when set) instead of the run's deal; when the contact has none and lanePipelineId is set, the card is created there (laneStageId, else the pipeline's first stage) already owned by the user; lanePipelineId or laneStageId without laneSource, or laneStageId without lanePipelineId, is refused; a lane never applies to an Assign-to-contact step. create_deal config {pipelineId (required), stageId, dealName, dealValue, allowDuplicates, status, source, assignedTo, leaveUnassigned}: leaveUnassigned true leaves the card unassigned when no assignee is set (default false: the card goes to the lead's owner). close_other_open_deals config {lostReason (required)}: closes the contact's OTHER open cards as lost with that reason, keeping the run's own card (each moves to its pipeline's lost stage with the usual stage-change effects; cards already won/lost, in the DPP Post-Close pipeline or in a pipeline with no lost stage are skipped; a re-run closes nothing twice); it needs the run's own deal, so use a deal trigger or a find_opportunity step first." + AUTOMATION_KEY_REFUSALS_NOTE)
     .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")
@@ -2050,10 +2158,25 @@ automations
 }));
 automations
     .command("publish <id>")
-    .description("Publish a draft workflow to live")
-    .action(run(async (client, id) => {
+    .description("Publish a draft workflow to live. The API binds a publish to the draft you reviewed and answers 409 without its configRevision, so this reads GET /automations/<id> and POSTs its configRevision as expectedConfigRevision (--expected-config-revision N uses the revision you reviewed and skips the read; a draft changed since then is refused 409). A draft holding an action config key the action does not read, or an unregistered action type, is refused 422 with code unknown_action_config_key / unknown_action_type listed in data.errors (with a \"Did you mean\" suggestion); the error text prints the whole refusal")
+    .option("--expected-config-revision <n>", "the configRevision of the draft you reviewed (from `automations` read / GET /automations/<id>); omit to read the current one")
+    .action(run(async (client, id, opts) => {
     assertUuid(id, "automation id");
-    return client.post(`/api/v1/automations/${encodeURIComponent(id)}/publish`, {});
+    let revision;
+    if (opts.expectedConfigRevision !== undefined) {
+        if (!/^\d+$/.test(opts.expectedConfigRevision.trim()))
+            throw new Error("--expected-config-revision must be a non-negative integer (the configRevision of the draft you reviewed).");
+        revision = Number(opts.expectedConfigRevision.trim());
+    }
+    else {
+        // GET /automations/:id answers { data: { ...automation, configRevision } }
+        const read = (await client.get(`/api/v1/automations/${encodeURIComponent(id)}`));
+        const rev = read?.data?.configRevision;
+        if (typeof rev !== "number")
+            throw new Error("The automation read carried no configRevision, so the publish cannot be bound to the draft. Nothing was published.");
+        revision = rev;
+    }
+    return client.post(`/api/v1/automations/${encodeURIComponent(id)}/publish`, { expectedConfigRevision: revision });
 }));
 automations
     .command("step-logs [id]")
@@ -2717,6 +2840,10 @@ const integrations = program.command("integrations").description("Integrations m
 const wordpressForms = integrations
     .command("wordpress-forms")
     .description("WordPress form intake addresses (Gravity Forms, WPForms, Elementor): submissions become contacts (form-intakes + contacts scopes, write tier; revoke: form-intakes)");
+wordpressForms
+    .command("status")
+    .description("Whether any intake address is ACTIVE and how many: { data: { hasActive, activeCount } } (GET /integrations/wordpress-forms/status). A boolean and a count only, never an address or token; read-only, API key scope integrations (a member: settings.view). A 403 exits 1 with the API's message")
+    .action(run(async (client) => client.get("/api/v1/integrations/wordpress-forms/status")));
 wordpressForms
     .command("list")
     .description("List every active intake address (newest first), then the revoked history (the newest 200 revocations), with the full URL of every active intake and received counts")
@@ -3651,6 +3778,28 @@ replyCapture
 }));
 // ---- lifecycle (master lead status + intake deals) ----
 // ---- general settings writes (09-15) ----
+/** Split an error message into its prefix and its trailing details object (the grammar's final token): try each `{` from the
+ *  left until the rest parses as a JSON object. */
+function splitErrorDetails(message) {
+    for (let i = message.indexOf("{"); i !== -1; i = message.indexOf("{", i + 1)) {
+        try {
+            const v = JSON.parse(message.slice(i));
+            if (v && typeof v === "object" && !Array.isArray(v))
+                return { prefix: message.slice(0, i).trimEnd(), details: v };
+        }
+        catch { /* next brace */ }
+    }
+    return { prefix: message, details: {} };
+}
+/** A settings conflict re-raised with a hint and the CURRENT settings: the original details object and the extra state are merged
+ *  into ONE final JSON object `{...details, hint, current}`, so nothing follows it. `current` is kept whole up to 20000 characters;
+ *  past that it is left out and `currentOmitted` says so (re-read with `settings get`). */
+function settingsConflictError(err, hint, current) {
+    const { prefix, details } = splitErrorDetails(err.message);
+    const whole = JSON.stringify(current ?? null);
+    const extra = whole.length <= 20000 ? { hint, current: current ?? null } : { hint, currentOmitted: `${whole.length} characters; re-read the settings` };
+    return new Error(`${prefix} ${JSON.stringify({ ...details, ...extra })}`);
+}
 // PATCH /api/v1/settings refuses a general-settings change without the settingsRevision the editor loaded
 // (400 expected_settings_revision_required) and answers 409 when another save landed first. Every general
 // write below reads the revision first and sends it; a 409 is re-raised with the current settings so the
@@ -3670,7 +3819,7 @@ async function patchGeneralSettings(client, body) {
     catch (err) {
         if (err instanceof Error && /^Conduyt API 409/.test(err.message)) {
             const current = await read();
-            throw new Error(`${err.message} — the account settings changed since revision ${expectedSettingsRevision ?? "?"} was read; re-run the command (current: ${JSON.stringify(current?.data ?? null).slice(0, 1500)})`);
+            throw settingsConflictError(err, `the account settings changed since revision ${expectedSettingsRevision ?? "?"} was read; re-run the command`, current?.data);
         }
         throw err;
     }
@@ -3694,7 +3843,7 @@ async function patchGeneralSettingsMerged(client, build) {
                 throw err;
             if (attempt === 1) {
                 const current = await read();
-                throw new Error(`${err.message} — the account settings changed twice while this was being saved (last revision read ${revision ?? "?"}); re-run the command (current: ${JSON.stringify(current?.data ?? null).slice(0, 1500)})`);
+                throw settingsConflictError(err, `the account settings changed twice while this was being saved (last revision read ${revision ?? "?"}); re-run the command`, current?.data);
             }
         }
     }
@@ -3907,6 +4056,14 @@ lifecycle
                 enabled: lostRaw?.enabled === true,
                 enabledAt: typeof lostRaw?.enabledAt === "string" ? lostRaw.enabledAt : null,
             },
+            // (card ownership per lane, 10-09) false = a booking uses the contact's existing open card in the intake pipeline. A stored value
+            // is shown as is; absent in a FULL snapshot (never saved; the runtime treats it as false) is false; absent in a REDUCED snapshot
+            // (a caller without settings.view) is null + note. The full view always carries `accountId` and the reduced one never does.
+            ...(typeof raw.bookingCreatesOwnCard === "boolean"
+                ? { bookingCreatesOwnCard: raw.bookingCreatesOwnCard }
+                : typeof raw.accountId === "string"
+                    ? { bookingCreatesOwnCard: false }
+                    : { bookingCreatesOwnCard: null, bookingCreatesOwnCardNote: "not visible to this role (needs settings.view)" }),
             masterStatuses: {
                 defaults: DEFAULTS,
                 customs,
@@ -3949,6 +4106,18 @@ lifecycle
         throw new Error("Pass --enable or --disable.");
     return patchGeneralSettings(client, { lostPropagation: { enabled: Boolean(opts.enable) } });
 }));
+lifecycle
+    .command("set-booking-creates-own-card")
+    .description("Set settings.bookingCreatesOwnCard (card ownership per lane; PATCH /settings, needs settings:edit). --enable: a booking creates a NEW card in the intake-deals pipeline and stage, owned by the booking's host, instead of using the contact's existing open card there. --disable (the default): the contact's existing open card is used. `lifecycle settings` shows the current value. A stale settings revision exits 1 with the conflict and the current settings")
+    .option("--enable", "each booking creates its own card owned by the host")
+    .option("--disable", "reuse the contact's open intake card (default)")
+    .action(run(async (client, opts) => {
+    if (opts.enable && opts.disable)
+        throw new Error("Pass either --enable or --disable, not both.");
+    if (opts.enable === undefined && opts.disable === undefined)
+        throw new Error("Pass --enable or --disable.");
+    return patchGeneralSettings(client, { bookingCreatesOwnCard: Boolean(opts.enable) });
+}));
 lifecycle
     .command("set-intake-deals")
     .description("Configure automatic deal creation on live intake (webhooks, public forms, public bookings). Even under --re-inbound always: bulk imports and staff/calendar/dialer-created appointments never mint, exact replays and same-source events within 10 min are skipped, and terminal-status contacts get no new deals")

package/package.json

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