conduyt 1.77.0 → 1.79.0

package/README.md

@@ -35,7 +35,8 @@ conduyt contacts list --limit 25        # list contacts (supports --cursor, --qu
 conduyt contacts get <id>               # fetch one contact (carries `revision`, `hasOutboundSms` and `hasOutboundEmail`: 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 merge <primaryId> <secondaryId...> [--confirm [--yes]]   # DESTRUCTIVE: a dry run by default (prints the impact); --confirm shows it, asks y/N, then merges (the losers are deleted); --yes skips the question; moved counts 409 and 503 merge_contacts_busy / merge_budget_exhausted + Retry-After exit 1, never retried
-conduyt contacts duplicates <id>                                    # GET /contacts/{id}/duplicate-proposals; prints { proposals, heldIdentifiers } (open and not_sure possible duplicates; read-only)
+conduyt contacts duplicates <id> [--cursor <c>] [--limit <n>] [--held-cursor <c>] [--held-limit <n>]   # GET /contacts/{id}/duplicate-proposals; prints { proposals, heldIdentifiers, total, nextCursor, membershipRevision, heldIdentifiersTotal, heldIdentifiersNextCursor, heldIdentifiersMembershipRevision } (open and not_sure possible duplicates; keyset paged; read-only)
+conduyt imports duplicates <importId> [--page <n>] [--per-page <n>]  # GET /imports/{id}/duplicate-proposals; the proposals one import raised on the records it created, every status, oldest first; prints { rows, meta: { page, per_page, total } }
 conduyt contacts duplicates decide <id> <proposalId> --as not_sure|different|merge   # POST the decision; not_sure keeps both visible, different is final, merge only records a pair ALREADY merged (never merges); 409 already_decided / not_merged and 403 other_record_not_editable exit 1
 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
@@ -46,6 +47,7 @@ conduyt chat mark-read <channelId> <messageId>   # readUpTo: marker moves to tha
 conduyt notifications list [--page n] [--per-page 1-200]   # prints { data, meta }: meta.latestByType = { type: { latest, count } } over the last 24 h, next to unreadCount / unreadByType
 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 list --board-snapshot --pipeline <id> --board-columns <stageId>[:<limit>],...   # every named column of one pipeline from ONE database snapshot (a moved deal is in exactly one column); prints { columns: [{ stageId, limit, deals }], meta: { board_snapshot: true } }; --page / --all / --stage / --stage-name / --health-* refused before any request; 503 board_snapshot_busy or gate_busy exits 1 with Retry-After
 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

package/dist/index.js

@@ -259,14 +259,28 @@ contacts
 const PROPOSAL_DECISIONS = ["not_sure", "different", "merge"];
 const duplicates = contacts
     .command("duplicates <id>")
-    .description("List the possible duplicates of contact <id> (GET /contacts/{id}/duplicate-proposals, contacts:view, read-only): prints { proposals, heldIdentifiers }. Each proposal has id (the <proposalId> for `contacts duplicates decide`), status (open | not_sure), rule, raisedHere and `other` { id, name, createdAt, visible, editable }; a record you cannot view is \"a contact you cannot view\" with no id. heldIdentifiers are emails or phones this record was not given because another record owns them (value-free). Decide a pair with `conduyt contacts duplicates decide <id> <proposalId> --as not_sure|different|merge`")
-    .action(run(async (client, id) => {
+    .description("List the possible duplicates of contact <id> (GET /contacts/{id}/duplicate-proposals, contacts:view, read-only): prints { proposals, heldIdentifiers }. Each proposal has id (the <proposalId> for `contacts duplicates decide`), status (open | not_sure), rule, raisedHere and `other` { id, name, createdAt, visible, editable }; a record you cannot view is \"a contact you cannot view\" with no id. heldIdentifiers are emails or phones this record was not given because another record owns them (value-free). Decide a pair with `conduyt contacts duplicates decide <id> <proposalId> --as not_sure|different|merge`. Paging: both lists are keyset paged, newest first; --cursor / --limit page the proposals, --held-cursor / --held-limit the held identifiers. The printed object also carries total and heldIdentifiersTotal (every line of each list, all pages), nextCursor and heldIdentifiersNextCursor (pass back as --cursor / --held-cursor; null on the last page) and membershipRevision / heldIdentifiersMembershipRevision (opaque digests of each list: when a later page answers another revision than page one, discard it and read page one again). A cursor this list did not issue is a 400 invalid_cursor (exit 1)")
+    .option("--cursor <cursor>", "the nextCursor of the previous proposals page, passed back UNCHANGED (opaque); omit for the first page")
+    .option("--limit <n>", "proposals per page, integer 1-100 (default 50); above 100 is refused, not capped")
+    .option("--held-cursor <cursor>", "the heldIdentifiersNextCursor of the previous held identifiers page, passed back UNCHANGED (opaque); omit for the first page")
+    .option("--held-limit <n>", "held identifiers per page, integer 1-100 (default 20)")
+    .action(run(async (client, id, opts) => {
     assertUuid(id, "contact id");
-    return client.get(`/api/v1/contacts/${encodeURIComponent(id)}/duplicate-proposals`);
+    const qs = new URLSearchParams();
+    if (opts.cursor !== undefined)
+        qs.set("cursor", opaqueCursorFlag(opts.cursor, "--cursor"));
+    if (opts.limit !== undefined)
+        qs.set("limit", String(strictIntFlag(opts.limit, "--limit", 1, 100)));
+    if (opts.heldCursor !== undefined)
+        qs.set("held_cursor", opaqueCursorFlag(opts.heldCursor, "--held-cursor"));
+    if (opts.heldLimit !== undefined)
+        qs.set("held_limit", String(strictIntFlag(opts.heldLimit, "--held-limit", 1, 100)));
+    const q = qs.toString();
+    return client.get(`/api/v1/contacts/${encodeURIComponent(id)}/duplicate-proposals${q ? `?${q}` : ""}`);
 }));
 duplicates
     .command("decide <id> <proposalId>")
-    .description("Record a decision on one possible-duplicate pair (POST /contacts/{id}/duplicate-proposals/{proposalId}; contacts:edit on BOTH records). --as is required, exactly one of: not_sure (keep both records visible; the pair stays listed and can be decided again), different (the two are different people: never shown again, FINAL), merge (record that the pair is ALREADY merged; this command NEVER merges: run `conduyt contacts merge` first, else 409 not_merged). Prints { id, status, decidedAt }. Refusals exit 1 with the status, message and code and are never retried: 409 already_decided, 409 not_merged, 403 other_record_not_editable, 404, 400")
+    .description("Record a decision on one possible-duplicate pair (POST /contacts/{id}/duplicate-proposals/{proposalId}; contacts:edit on BOTH records). --as is required, exactly one of: not_sure (keep both records visible; the pair stays listed and can be decided again), different (the two are different people: never shown again, FINAL), merge (record that the pair is ALREADY merged; this command NEVER merges: run `conduyt contacts merge` first, else 409 not_merged). Prints { id, status, decidedAt, previousMembershipRevision, membershipRevision, total }: membershipRevision and total are the proposals list AFTER the decision (the same digest and count `contacts duplicates` answers), previousMembershipRevision the digest just BEFORE it (equal on an idempotent repeat); keep loaded pages only when previousMembershipRevision equals the revision you hold. Refusals exit 1 with the status, message and code and are never retried: 409 already_decided, 409 not_merged, 403 other_record_not_editable, 404, 400")
     .option("--as <decision>", "not_sure | different | merge (required)")
     .action(run(async (client, id, proposalId, opts) => {
     assertUuid(id, "contact id");
@@ -277,6 +291,42 @@ duplicates
         throw new Error(`--as must be exactly one of ${PROPOSAL_DECISIONS.join(", ")} (got "${opts.as}").`);
     return client.post(`/api/v1/contacts/${encodeURIComponent(id)}/duplicate-proposals/${encodeURIComponent(proposalId)}`, { decision: opts.as });
 }));
+/** a whole-number flag in [min, max]: digits only (no sign, decimal, exponent or hex), so "1e1" or "0x10" never pass as 10 or 16 */
+function strictIntFlag(raw, flag, min, max) {
+    const t = raw.trim();
+    if (!/^\d+$/.test(t))
+        throw new Error(`${flag} must be a whole number ${min}-${max} (got ${JSON.stringify(raw)}).`);
+    const n = Number(t);
+    if (n < min || n > max)
+        throw new Error(`${flag} must be a whole number ${min}-${max} (got ${JSON.stringify(raw)}).`);
+    return n;
+}
+/** an opaque cursor is sent exactly as given; a blank one is refused (the API would answer page one, silently restarting) */
+function opaqueCursorFlag(raw, flag) {
+    if (raw.trim() === "")
+        throw new Error(`${flag} was provided but is blank: pass the cursor from the previous page unchanged, or omit it for the first page.`);
+    return raw;
+}
+// Duplicate proposals look (board #95, app f2d638db6): the import results rows "Created, similar record exists".
+const imports = program.command("imports").description("Import jobs (contacts / opportunities / companies imports)");
+imports
+    .command("duplicates <importId>")
+    .description("List the duplicate proposals one import raised on the records it created (GET /imports/{id}/duplicate-proposals, contacts:view, read-only): one row per proposal, every status (open | not_sure | different | merged; a merged pair reads merged), oldest first. Prints { rows, meta: { page, per_page, total } } (total counts every row of the import). Each row: proposalId, status, rowNum (the import file's row number), createdAt, decidedAt, decidedByName, newRecord (the record the import created), similar (the existing record it may duplicate), matchedOn (kinds only, such as phone or phone + company, never a value), keptName; newRecord and similar are { id, name, visible, editable, live }. A record you cannot view has no id and the name \"A contact you cannot view\". Decide a row with `conduyt contacts duplicates decide <newRecord.id> <proposalId> --as ...` (contacts:edit on both records). An owner, admin or view-all key reads any import of the account, any other key only the imports its user ran (404 otherwise). The route is page based: --page / --per-page, not a cursor")
+    .option("--page <n>", "page number, integer 1-100000 (default 1)")
+    .option("--per-page <n>", "rows per page, integer 1-100 (default 50); above 100 is refused, not capped")
+    .option("--cursor <cursor>", "not supported (the import rows page with --page); passing it exits 1 and sends no request")
+    .action(run(async (client, importId, opts) => {
+    if (opts.cursor !== undefined)
+        throw new Error("imports duplicates does not support --cursor (the API pages the import rows with page and per_page); use --page <n> and --per-page <n>.");
+    assertUuid(importId, "import id");
+    const qs = new URLSearchParams();
+    if (opts.page !== undefined)
+        qs.set("page", String(strictIntFlag(opts.page, "--page", 1, 100000)));
+    if (opts.perPage !== undefined)
+        qs.set("per_page", String(strictIntFlag(opts.perPage, "--per-page", 1, 100)));
+    const q = qs.toString();
+    return client.get(`/api/v1/imports/${encodeURIComponent(importId)}/duplicate-proposals${q ? `?${q}` : ""}`);
+}));
 contacts
     .command("merge <primaryId> <secondaryIds...>")
     .description("DESTRUCTIVE merge of duplicate contacts (POST /contacts/merge; owner or admin): <primaryId> survives and receives the records of every <secondaryIds> contact, which are then DELETED (no undelete). By default a DRY RUN: nothing changes, it prints the impact { primary, secondaries, counts, totalRecords, guardCounts, filledFields, identifierOverflow, blockers }. --confirm repeats the dry run, shows the impact (the records that move, and separately the guard counts: chat messages, quick notes, identifiers, outbox rows, which are not in the records total), asks y/N and then merges, sending the values that dry run returned (expectedCounts, expectedGuardCounts, expectedIdentifiers). LOSER ORDER: losers are merged in the order given: for each field the survivor lacks, the first loser in this order with a value wins; reorder to change precedence; the dry run's filledFields shows which fields will be filled. WHAT IS PINNED: the server refuses (409) if the record counts, guard counts or identifier plan moved; other field edits made after this preview (a loser's name, company, source, address) are not detected; --yes skips the question (scripts; needs --confirm). A refusal exits 1 with the status, the API's message and its code and is NEVER retried: 409 \"Merge impact changed\" (preview again), 409 queued work, 400 / 404, and 503 merge_contacts_busy / merge_budget_exhausted with `[Retry-After: <N>s]` (nothing changed: wait that long, then run again).")
@@ -466,6 +516,38 @@ function rejectBlankFlags(flags) {
         }
     }
 }
+/** GET /deals board_snapshot=true limits (the app's lib/deal-board-snapshot-limits, contract at 5729bc7b4). */
+const BOARD_SNAPSHOT_MAX_COLUMNS = 50;
+const BOARD_SNAPSHOT_MAX_COLUMN_ROWS = 1000;
+const BOARD_SNAPSHOT_MAX_TOTAL_ROWS = 5000;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** --board-columns <stageId>[:<limit>],...: the server's own rules checked before any request (1-50 columns, UUID stage
+ *  ids, no stage twice, limit a whole number 1-1000, default --limit, at most 5000 rows in total); the wire value. */
+function parseBoardColumnsFlag(raw, defaultLimit) {
+    const entries = raw.split(",").map((e) => e.trim());
+    if (raw.trim() === "" || entries.some((e) => e === ""))
+        throw new Error("--board-columns must be <stageId>[:<limit>],... with no blank entry.");
+    if (entries.length > BOARD_SNAPSHOT_MAX_COLUMNS)
+        throw new Error(`--board-columns names at most ${BOARD_SNAPSHOT_MAX_COLUMNS} columns (got ${entries.length}).`);
+    const seen = new Set();
+    let total = 0;
+    const out = [];
+    for (const entry of entries) {
+        const parts = entry.split(":");
+        const id = parts[0].trim();
+        if (parts.length > 2 || !UUID_RE.test(id))
+            throw new Error(`--board-columns expects <stageId>[:<limit>] entries with a stage UUID; got ${JSON.stringify(entry)}.`);
+        const limit = parts.length === 2 ? strictIntFlag(parts[1], `--board-columns limit for ${id}`, 1, BOARD_SNAPSHOT_MAX_COLUMN_ROWS) : defaultLimit;
+        if (seen.has(id.toLowerCase()))
+            throw new Error(`--board-columns names stage ${id} more than once.`);
+        seen.add(id.toLowerCase());
+        total += limit;
+        out.push(parts.length === 2 ? `${id}:${limit}` : id);
+    }
+    if (total > BOARD_SNAPSHOT_MAX_TOTAL_ROWS)
+        throw new Error(`--board-columns asks for ${total} rows; one snapshot answers at most ${BOARD_SNAPSHOT_MAX_TOTAL_ROWS}. Read deeper columns with --stage.`);
+    return out.join(",");
+}
 /** The six Pipeline health checks (GET /deals health_check, GET /deals/inspection check); the API validates the value. */
 const PIPELINE_HEALTH_CHECKS = ["high_value_idle", "stale", "unassigned", "needs_action", "missing_close_date", "missing_contact"];
 deals
@@ -484,6 +566,8 @@ deals
     .option("--health-offset <n>", "with --health-summary and --health-check: deals to skip (default 0); prefer --health-cursor")
     .option("--health-cursor <token>", "with --health-summary and --health-check: continue after this cursor, the nextCursor of the previous page, passed back UNCHANGED (opaque signed token; a blank, forged or foreign one is a 400 with health_cursor_blank / health_cursor_invalid / health_cursor_context / health_cursor_needs_check)")
     .option("--health-rows-only", "with --health-summary and --health-check: answer only that page of the check's deals ({check, offset, items, hasMore, nextCursor}), without the summary")
+    .option("--board-snapshot", "read every column in --board-columns from ONE database snapshot (a deal moved during the read is in exactly one column). Needs --pipeline or --pipeline-name and --board-columns; refused (exit 1, no request) with --page, --all, --stage, --stage-name or any --health-* flag. Prints { columns: [{ stageId, limit, deals }], meta: { board_snapshot: true } }: columns in the order named, each column's deals exactly what --stage <stageId> --limit <limit> rows-only answers, no totals; deals.length equal to limit means the column may hold more. A 503 board_snapshot_busy (the snapshot could not finish in its budget: read the columns one by one or retry) or gate_busy (any deals list call: the access check could not finish in time) exits 1 with the code and Retry-After; never retried")
+    .option("--board-columns <columns>", `with --board-snapshot: <stageId>[:<limit>],... in answer order; 1-${BOARD_SNAPSHOT_MAX_COLUMNS} live stages of the pipeline, no stage twice, limit 1-${BOARD_SNAPSHOT_MAX_COLUMN_ROWS} (default --limit, itself default 50), at most ${BOARD_SNAPSHOT_MAX_TOTAL_ROWS} rows in total`)
     .action(run(async (client, opts) => {
     // A provided-but-blank filter must error, not silently become "no filter":
     // buildQuery drops empty strings, so a blank flag would never reach the
@@ -501,6 +585,44 @@ deals
             throw new Error(`${flag} was provided but is blank. Omit it to skip the filter, or pass a real value.`);
         }
     }
+    // Board snapshot (#116 for app #111, contract 5729bc7b4): one pipeline's columns from ONE database snapshot. Its
+    // conflicts are refused here, before any request; the answer is { columns, meta } (no data.data / meta.total), so it
+    // never goes through the health branch or the --all / truncation logic below.
+    if (opts.boardSnapshot || opts.boardColumns !== undefined) {
+        if (!opts.boardSnapshot)
+            throw new Error("--board-columns needs --board-snapshot.");
+        const conflicts = [
+            ["--page", opts.page !== undefined], ["--all", opts.all === true],
+            ["--stage", opts.stage !== undefined], ["--stage-name", opts.stageName !== undefined],
+            ["--health-summary", opts.healthSummary === true], ["--health-check", opts.healthCheck !== undefined],
+            ["--health-limit", opts.healthLimit !== undefined], ["--health-offset", opts.healthOffset !== undefined],
+            ["--health-cursor", opts.healthCursor !== undefined], ["--health-rows-only", opts.healthRowsOnly === true],
+        ].filter(([, hit]) => hit).map(([flag]) => flag);
+        if (conflicts.length > 0) {
+            throw new Error(`--board-snapshot cannot be combined with ${conflicts.join(", ")}: it answers every named column's first rows, rows only, from one snapshot.`);
+        }
+        if (opts.pipeline === undefined && opts.pipelineName === undefined)
+            throw new Error("--board-snapshot needs --pipeline or --pipeline-name.");
+        if (opts.boardColumns === undefined)
+            throw new Error("--board-snapshot needs --board-columns <stageId>[:<limit>],...");
+        const perPage = opts.limit === undefined ? 50 : strictIntFlag(opts.limit, "--limit", 1, BOARD_SNAPSHOT_MAX_COLUMN_ROWS);
+        const columns = parseBoardColumnsFlag(opts.boardColumns, perPage);
+        const usp = new URLSearchParams();
+        if (opts.pipeline !== undefined)
+            usp.set("pipeline", opts.pipeline);
+        if (opts.pipelineName !== undefined)
+            usp.set("pipeline_name", opts.pipelineName);
+        if (opts.limit !== undefined)
+            usp.set("per_page", String(perPage));
+        usp.set("board_snapshot", "true");
+        usp.set("board_columns", columns);
+        const answer = await client.get(`/api/v1/deals?${usp.toString()}`);
+        const data = answer?.data;
+        if (!data || !Array.isArray(data.columns) || data.meta?.board_snapshot !== true) {
+            throw new Error("--board-snapshot: the API answered without { columns, meta: { board_snapshot: true } }. Aborting rather than print another shape.");
+        }
+        return answer;
+    }
     // Pipeline health (app 10-08): a different answer shape (no data.data / meta.total), so it never goes through the
     // --all / truncation logic below. The API validates the check, the paging and the cursor (400 + code).
     const healthFlags = [

package/package.json

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

package/dist/action-config-typos.js

@@ -1,78 +0,0 @@
-/**
- * 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));
-}