@audienti/cli 0.1.78 → 0.1.80

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to the Audienti CLI are documented here.
 
 ## [Unreleased]
 
+## [0.1.80] - 2026-09-28
+
+### Added
+
+- Run the motion list and motion health actions from the CLI: `motions bulk-add-tag --tag`, `bulk-remove-tag --tag`, `bulk-update-principal --principal`, `bulk-update-status --status` (prints any motion the lifecycle rules blocked), `retire-strategy --strategy`, `refresh-launch-check`, `refresh-launch-checks`, and `update-premise --premise`.
+
+## [0.1.79] - 2026-09-28
+
+### Added
+
+- Run the remaining prospect page actions from the CLI: `prospects defer`, `delay --for`, `monitor`, `unmonitor`, `rename --name`, `import-post --url`, `sync --social-cookie`, `cancel-event --event`, `queue-draft` (optional `--context` JSON object), `rewrite`, `engage --type` (with `--post`, `--comment`, `--reply-to`, `--request-event`, `--queue-action` and `--principal` targets), `reject-selected`, and `intake --url`.
+- Add `events retry`, `profiles delete`, `companies stop-pursuing`, `content defer --for`, `network-ops adopt --target-account --motion`, `network-ops ignore`, `reconciliations add-to-motion --motion`, and `reconciliations ignore`.
+- Add `inbox-ops update-filters`, `inbox-ops draft-reply`, `inbox-ops reply --message`, and `inbox-ops adopt`. Each reply sends a fresh reply token so a retried command cannot send twice.
+
 ## [0.1.78] - 2026-09-27
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@audienti/cli",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "description": "Agent-first command-line client for Audienti.",
   "type": "module",
   "bin": {

package/src/api-client.js

@@ -675,6 +675,59 @@ export class AudientiClient {
     });
   }
 
+  bulkAddMotionTag(accountId, body) {
+    return this.requestJson(accountPath(accountId, ["motions", "bulk_add_tag"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  bulkRemoveMotionTag(accountId, body) {
+    return this.requestJson(accountPath(accountId, ["motions", "bulk_remove_tag"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  bulkUpdateMotionPrincipal(accountId, body) {
+    return this.requestJson(accountPath(accountId, ["motions", "bulk_update_principal"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  bulkUpdateMotionStatus(accountId, body) {
+    return this.requestJson(accountPath(accountId, ["motions", "bulk_update_status"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  retireMotionStrategy(accountId, motionId, strategyId) {
+    return this.requestJson(accountPath(accountId, ["motions", motionId, "strategies", strategyId, "retire"]), {
+      method: "POST"
+    });
+  }
+
+  refreshMotionLaunchCheck(accountId, motionId) {
+    return this.requestJson(accountPath(accountId, ["motions", motionId, "refresh_launch_check"]), {
+      method: "POST"
+    });
+  }
+
+  refreshMotionLaunchChecks(accountId) {
+    return this.requestJson(accountPath(accountId, ["motions", "refresh_launch_checks"]), {
+      method: "POST"
+    });
+  }
+
+  updateMotionPremise(accountId, motionId, body) {
+    return this.requestJson(accountPath(accountId, ["motions", motionId, "update_premise"]), {
+      method: "PATCH",
+      body
+    });
+  }
+
   createQuickStart(accountId, body) {
     return this.requestJson(accountPath(accountId, ["quick_start"]), {
       method: "POST",
@@ -794,6 +847,160 @@ export class AudientiClient {
     });
   }
 
+  deferProspect(accountId, prospectId) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "defer"]), {
+      method: "POST"
+    });
+  }
+
+  delayProspect(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "delay"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  monitorProspect(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "monitor"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  unmonitorProspect(accountId, prospectId) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "unmonitor"]), {
+      method: "POST"
+    });
+  }
+
+  renameProspect(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "display_name"]), {
+      method: "PATCH",
+      body
+    });
+  }
+
+  importProspectPost(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "import_post"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  syncProspect(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "sync"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  cancelProspectScheduledEvent(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "cancel_scheduled_event"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  writeProspectQueueDraft(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "write"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  rewriteProspectQueueDraft(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "rewrite"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  engageProspect(accountId, prospectId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", prospectId, "engage"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  rejectSelectedProspects(accountId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", "reject_selected"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  intakeProspect(accountId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["prospects", "intake"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  retryEvent(accountId, eventId) {
+    return this.requestJson(accountPath(accountId, ["events", eventId, "retry"]), {
+      method: "POST"
+    });
+  }
+
+  deleteProfile(accountId, profileId) {
+    return this.requestJson(accountPath(accountId, ["profiles", profileId]), {
+      method: "DELETE"
+    });
+  }
+
+  stopPursuingCompany(accountId, companyId) {
+    return this.requestJson(accountPath(accountId, ["companies", companyId, "stop_pursuing"]), {
+      method: "POST"
+    });
+  }
+
+  contentDefer(accountId, workItemId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["content_ops", "work_items", workItemId, "defer"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  updateInboxOpsFilters(accountId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["inbox_ops", "filters"]), {
+      method: "PATCH",
+      body
+    });
+  }
+
+  inboxOpsReply(accountId, rowId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["inbox_ops", rowId, "reply"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  inboxOpsWriteReply(accountId, rowId) {
+    return this.requestJson(accountPath(accountId, ["inbox_ops", rowId, "reply", "write"]), {
+      method: "POST"
+    });
+  }
+
+  inboxOpsAdopt(accountId, rowId, body = {}) {
+    return this.requestJson(accountPath(accountId, ["inbox_ops", rowId, "adopt"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  reconciliationAddToMotion(accountId, sourceKey, body = {}) {
+    return this.requestJson(accountPath(accountId, ["reconciliations", sourceKey, "add_to_motion"]), {
+      method: "POST",
+      body
+    });
+  }
+
+  reconciliationIgnore(accountId, sourceKey) {
+    return this.requestJson(accountPath(accountId, ["reconciliations", sourceKey, "ignore"]), {
+      method: "POST"
+    });
+  }
+
   prospectSequencePreview(accountId, prospectId, body = {}) {
     return this.requestJson(accountPath(accountId, ["prospects", prospectId, "sequence_preview"]), {
       method: "POST",
@@ -883,9 +1090,10 @@ export class AudientiClient {
     return this.requestJson(accountPath(accountId, ["operator"], query));
   }
 
-  networkOpsAction(accountId, rowId, action) {
+  networkOpsAction(accountId, rowId, action, body) {
     return this.requestJson(accountPath(accountId, ["network_ops", rowId, action]), {
-      method: "POST"
+      method: "POST",
+      ...(body === undefined ? {} : { body })
     });
   }
 

package/src/cli.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
 import { createServer } from "node:http";
 import { spawn } from "node:child_process";
-import { randomBytes } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -309,6 +309,8 @@ async function dispatch(argv, context) {
 
   const [resource, action, ...rest] = args;
   const normalizedResource = normalizeResource(resource);
+  const parityActionTopic = `${normalizedResource} ${action}`;
+  if (PARITY_ACTION_COMMANDS.has(parityActionTopic)) return runParityActionCommand(parityActionTopic, rest, context, { accountOverride });
 
   if (normalizedResource === "auth" && action === "token") return authToken(rest, context);
   if (normalizedResource === "auth" && action === "login") return authLogin(rest, context);
@@ -3335,10 +3337,21 @@ async function motionsUpdate(args, context, { accountOverride } = {}) {
 
   const { client, accountId } = await requireAccountContext(context, { accountOverride });
   const motion = await client.updateMotion(accountId, positionals[0], { motion: await motionUpdatePayload(values) });
-  if (values.json) return writeJson(context.stdout, motion);
+  const statusBlocked = motion?.status_change?.status === "blocked";
+  if (values.json) {
+    writeJson(context.stdout, motion);
+    return statusBlocked ? 1 : undefined;
+  }
 
   writeLine(context.stdout, `Updated motion ${display(motion?.name)} (${display(motion?.prefix_id)}).`);
   renderMotion(motion, context);
+  if (!statusBlocked) return undefined;
+
+  writeLine(
+    context.stderr,
+    `Status not changed to ${display(motion.status_change.requested_status)}: ${display(motion.status_change.reason)}. Other changes were saved.`
+  );
+  return 1;
 }
 
 async function motionUpdatePayload(values) {
@@ -14056,3 +14069,424 @@ const HELP_TOPICS = new Map([
     "  Operator outcome writeback is implemented for prospect rows, not visibility rows."
   ].join("\n")]
 ]);
+
+// Single-purpose actions that mirror one web button each (#2300, #2302).
+// Every entry calls one API route that shares its service with the web action.
+const ACCOUNT_OPTION_USAGE = "[--json] [--account <acct_id>]";
+const PARITY_ACTION_COMMANDS = new Map([
+  ["prospects defer", {
+    usage: "audienti prospects defer <prsp_id>",
+    purpose: "Push one prospect out of the queue for 24 hours, like Defer in the queue.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/defer.json",
+    run: (client, accountId, [id]) => client.deferProspect(accountId, id),
+    done: ([id]) => `Deferred prospect ${id} for 24 hours.`
+  }],
+  ["prospects delay", {
+    usage: "audienti prospects delay <prsp_id> --for <1_day|1_week|1_month|3_months|6_months>",
+    purpose: "Delay one prospect and move it to the Delayed list until the window ends.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/delay.json",
+    options: { for: { type: "string" } },
+    required: ["for"],
+    run: (client, accountId, [id], values) => client.delayProspect(accountId, id, { delay_duration: values.for }),
+    done: ([id], payload) => `Delayed prospect ${id} until ${display(payload?.undelay_at)}.`
+  }],
+  ["prospects monitor", {
+    usage: "audienti prospects monitor <prsp_id> [--note <text>]",
+    purpose: "Move one prospect to monitoring, like Monitor on the prospect page.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/monitor.json",
+    options: { note: { type: "string" } },
+    run: (client, accountId, [id], values) => client.monitorProspect(accountId, id, compactObject({ monitor_note: values.note })),
+    done: ([id]) => `Monitoring prospect ${id}.`
+  }],
+  ["prospects unmonitor", {
+    usage: "audienti prospects unmonitor <prsp_id>",
+    purpose: "Stop monitoring one prospect.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/unmonitor.json",
+    run: (client, accountId, [id]) => client.unmonitorProspect(accountId, id),
+    done: ([id]) => `Stopped monitoring prospect ${id}.`
+  }],
+  ["prospects rename", {
+    usage: "audienti prospects rename <prsp_id> --name <display_name>",
+    purpose: "Change a prospect's display name. Backend admins only, like the web action.",
+    api: "PATCH /api/v1/accounts/:account_id/prospects/:id/display_name.json",
+    options: { name: { type: "string" } },
+    required: ["name"],
+    run: (client, accountId, [id], values) => client.renameProspect(accountId, id, { display_name: values.name }),
+    done: ([id]) => `Renamed prospect ${id}.`
+  }],
+  ["prospects import-post", {
+    usage: "audienti prospects import-post <prsp_id> --url <post_url> [--topic <topic_id>]",
+    purpose: "Import one LinkedIn post for a prospect in the background.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/import_post.json",
+    options: { url: { type: "string" }, topic: { type: "string" } },
+    required: ["url"],
+    run: (client, accountId, [id], values) => client.importProspectPost(accountId, id, compactObject({ url: values.url, topic_id: values.topic })),
+    done: ([id]) => `Queued post import for prospect ${id}.`
+  }],
+  ["prospects sync", {
+    usage: "audienti prospects sync <prsp_id> --social-cookie <id>",
+    purpose: "Queue a message and email sync for one prospect through the selected LinkedIn account and other eligible sync accounts.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/sync.json",
+    options: { "social-cookie": { type: "string" } },
+    required: ["social-cookie"],
+    run: (client, accountId, [id], values) => client.syncProspect(accountId, id, compactObject({ social_cookie_id: values["social-cookie"] })),
+    done: ([id]) => `Queued message sync for prospect ${id}.`
+  }],
+  ["prospects cancel-event", {
+    usage: "audienti prospects cancel-event <prsp_id> --event <event_id>",
+    purpose: "Cancel one scheduled event for a prospect.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/cancel_scheduled_event.json",
+    options: { event: { type: "string" } },
+    required: ["event"],
+    run: (client, accountId, [id], values) => client.cancelProspectScheduledEvent(accountId, id, { event_id: values.event }),
+    done: ([id], payload) => `Canceled scheduled event ${display(payload?.event?.id)} for prospect ${id}.`
+  }],
+  ["prospects queue-draft", {
+    usage: "audienti prospects queue-draft <prsp_id> [--context <json_object>] [--angle <n>]",
+    purpose: "Write the queue draft for one prospect, like Write in the queue composer. Without --context the server uses the prospect's current queue action.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/write.json",
+    options: { context: { type: "string" }, angle: { type: "string" } },
+    parse: (values) => ({ ...values, context: parseJsonObjectOption(values.context, "--context") }),
+    run: (client, accountId, [id], values) => client.writeProspectQueueDraft(accountId, id, compactObject({ context: values.context, angle_index: values.angle })),
+    done: ([id]) => `Wrote queue draft for prospect ${id}.`
+  }],
+  ["prospects rewrite", {
+    usage: "audienti prospects rewrite <prsp_id> [--subject <text>] [--message <text>] [--angle <n>]",
+    purpose: "Start a fresh queue draft for one prospect in the background.",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/rewrite.json",
+    options: { subject: { type: "string" }, message: { type: "string" }, angle: { type: "string" } },
+    run: (client, accountId, [id], values) => client.rewriteProspectQueueDraft(accountId, id, compactObject({ subject: values.subject, message: values.message, angle_index: values.angle })),
+    done: ([id]) => `Started queue draft rewrite for prospect ${id}.`
+  }],
+  ["prospects engage", {
+    usage: "audienti prospects engage <prsp_id> --type <action_type> [--message <text>] [--subject <text>] [--message-mode <mode>] [--social-cookie <id>] [--profile <id>] [--scheduled-at <iso8601>] [--post <post_id>] [--comment <comment_id>] [--reply-to <event_id>] [--request-event <event_id>] [--request-mode blank] [--queue-action] [--principal <account_user_id>]",
+    purpose: "Run one manual engagement for a prospect with the same rules as the prospect composer. Use --post or --comment for post likes and comments, --reply-to for a message reply, and --queue-action to act like the queue composer (a connection request on a disconnected LinkedIn account is prepared, not sent).",
+    api: "POST /api/v1/accounts/:account_id/prospects/:id/engage.json",
+    options: {
+      type: { type: "string" },
+      message: { type: "string" },
+      subject: { type: "string" },
+      "message-mode": { type: "string" },
+      "social-cookie": { type: "string" },
+      profile: { type: "string" },
+      "scheduled-at": { type: "string" },
+      post: { type: "string" },
+      comment: { type: "string" },
+      "reply-to": { type: "string" },
+      "request-event": { type: "string" },
+      "request-mode": { type: "string" },
+      "queue-action": { type: "boolean" },
+      principal: { type: "string" }
+    },
+    required: ["type"],
+    run: (client, accountId, [id], values) => client.engageProspect(accountId, id, compactObject({
+      action_type: values.type,
+      message: values.message,
+      subject: values.subject,
+      message_mode: values["message-mode"],
+      engage_point_id: values["social-cookie"],
+      profile_id: values.profile,
+      scheduled_at: values["scheduled-at"],
+      mention_id: values.post,
+      comment_id: values.comment,
+      message_id: values["reply-to"],
+      request_event_id: values["request-event"],
+      request_mode: values["request-mode"],
+      queue_action: values["queue-action"] ? true : undefined,
+      principal_account_user_id: values.principal
+    })),
+    done: (_positionals, payload) => display(payload?.message)
+  }],
+  ["prospects reject-selected", {
+    usage: "audienti prospects reject-selected <prsp_id> [<prsp_id> ...]",
+    minPositionals: 1,
+    maxPositionals: Infinity,
+    purpose: "Reject several prospects at once. Locked or unavailable prospects are reported as failed.",
+    api: "POST /api/v1/accounts/:account_id/prospects/reject_selected.json",
+    run: (client, accountId, ids) => client.rejectSelectedProspects(accountId, { prospect_ids: ids }),
+    done: (_positionals, payload) => `Rejected ${payload?.rejected?.length ?? 0}; failed ${payload?.failed?.length ?? 0}.`
+  }],
+  ["prospects intake", {
+    usage: "audienti prospects intake --url <linkedin_url> [--list <list_id>] [--assign <account_user_id>] [--signal <custom_signal_id>]",
+    minPositionals: 0,
+    maxPositionals: 0,
+    purpose: "Add one LinkedIn person by URL, like Add prospect on the web.",
+    api: "POST /api/v1/accounts/:account_id/prospects/intake.json",
+    options: { url: { type: "string" }, list: { type: "string" }, assign: { type: "string" }, signal: { type: "string" } },
+    required: ["url"],
+    run: (client, accountId, _positionals, values) => client.intakeProspect(accountId, compactObject({
+      url: values.url,
+      list_id: values.list,
+      assigned_to_account_user_id: values.assign,
+      custom_signal_id: values.signal
+    })),
+    done: () => "Prospect intake queued."
+  }],
+  ["events retry", {
+    usage: "audienti events retry <event_id>",
+    purpose: "Retry one failed event, with the same eligibility rules as the web retry button.",
+    api: "POST /api/v1/accounts/:account_id/events/:id/retry.json",
+    run: (client, accountId, [id]) => client.retryEvent(accountId, id),
+    done: ([id], payload) => `Retried event ${id} as ${display(payload?.event?.id)}.`
+  }],
+  ["profiles delete", {
+    usage: "audienti profiles delete <profile_id>",
+    purpose: "Remove one profile from its prospect. Backend admins only, like the web action.",
+    api: "DELETE /api/v1/accounts/:account_id/profiles/:id.json",
+    run: (client, accountId, [id]) => client.deleteProfile(accountId, id),
+    done: ([id]) => `Removed profile ${id}.`
+  }],
+  ["companies stop-pursuing", {
+    usage: "audienti companies stop-pursuing <company_profile_id>",
+    purpose: "Stop pursuing one company, like Stop pursuing on the company page.",
+    api: "POST /api/v1/accounts/:account_id/companies/:id/stop_pursuing.json",
+    run: (client, accountId, [id]) => client.stopPursuingCompany(accountId, id),
+    done: ([id]) => `Stopped pursuing company ${id}.`
+  }],
+  ["content defer", {
+    usage: "audienti content defer <work_item_id> --for <1_day|1_week|1_month|3_months|6_months>",
+    purpose: "Defer one content work item.",
+    api: "POST /api/v1/accounts/:account_id/content_ops/work_items/:id/defer.json",
+    options: { for: { type: "string" } },
+    required: ["for"],
+    run: (client, accountId, [id], values) => client.contentDefer(accountId, id, { delay_duration: values.for }),
+    done: ([id]) => `Deferred work item ${id}.`
+  }],
+  ["inbox-ops update-filters", {
+    usage: "audienti inbox-ops update-filters [--subscriptions <true|false>] [--automated-no-reply <true|false>] [--provider-promotions <true|false>] [--sender-allow <email>]... [--sender-filter <email>]... [--domain-allow <domain>]... [--domain-filter <domain>]...",
+    minPositionals: 0,
+    maxPositionals: 0,
+    purpose: "Save the owner's Inbox Ops email filters. Rule flags replace the saved list for that rule.",
+    api: "PATCH /api/v1/accounts/:account_id/inbox_ops/filters.json",
+    options: {
+      subscriptions: { type: "string" },
+      "automated-no-reply": { type: "string" },
+      "provider-promotions": { type: "string" },
+      "sender-allow": { type: "string", multiple: true },
+      "sender-filter": { type: "string", multiple: true },
+      "domain-allow": { type: "string", multiple: true },
+      "domain-filter": { type: "string", multiple: true }
+    },
+    run: (client, accountId, _positionals, values) => client.updateInboxOpsFilters(accountId, compactObject({
+      subscriptions: values.subscriptions,
+      automated_no_reply: values["automated-no-reply"],
+      provider_promotions: values["provider-promotions"],
+      sender_allow_rules: values["sender-allow"],
+      sender_filter_rules: values["sender-filter"],
+      domain_allow_rules: values["domain-allow"],
+      domain_filter_rules: values["domain-filter"]
+    })),
+    done: () => "Saved Inbox Ops filters."
+  }],
+  ["inbox-ops reply", {
+    usage: "audienti inbox-ops reply <row_id> --message <text> [--subject <text>]",
+    purpose: "Queue a reply to one Inbox Ops row. Each run sends a new reply token.",
+    api: "POST /api/v1/accounts/:account_id/inbox_ops/:row_id/reply.json",
+    options: { message: { type: "string" }, subject: { type: "string" } },
+    required: ["message"],
+    run: (client, accountId, [rowId], values) => client.inboxOpsReply(accountId, rowId, compactObject({
+      message: values.message,
+      subject: values.subject,
+      reply_token: randomUUID()
+    })),
+    done: ([rowId], payload) => `Reply ${display(payload?.status)} for ${rowId}.`
+  }],
+  ["inbox-ops draft-reply", {
+    usage: "audienti inbox-ops draft-reply <row_id>",
+    purpose: "Draft a reply for one Inbox Ops row without sending it.",
+    api: "POST /api/v1/accounts/:account_id/inbox_ops/:row_id/reply/write.json",
+    run: (client, accountId, [rowId]) => client.inboxOpsWriteReply(accountId, rowId),
+    done: (_positionals, payload) => display(payload?.message ?? payload?.body)
+  }],
+  ["inbox-ops adopt", {
+    usage: "audienti inbox-ops adopt <row_id> [--target-account <acct_id>] [--motion <motion_id>]",
+    purpose: "Adopt the prospect behind one Inbox Ops row.",
+    api: "POST /api/v1/accounts/:account_id/inbox_ops/:row_id/adopt.json",
+    options: { "target-account": { type: "string" }, motion: { type: "string" } },
+    run: (client, accountId, [rowId], values) => client.inboxOpsAdopt(accountId, rowId, compactObject({
+      target_account_id: values["target-account"],
+      motion_id: values.motion
+    })),
+    done: ([rowId]) => `Adopted ${rowId}.`
+  }],
+  ["network-ops adopt", {
+    usage: "audienti network-ops adopt <row_id> --target-account <acct_id> --motion <motion_id>",
+    purpose: "Accept one inbound connection request and adopt the person into a motion in an account owned by the request's LinkedIn account owner.",
+    api: "POST /api/v1/accounts/:account_id/network_ops/:row_id/adopt.json",
+    options: { "target-account": { type: "string" }, motion: { type: "string" } },
+    required: ["target-account", "motion"],
+    run: (client, accountId, [rowId], values) => client.networkOpsAction(accountId, rowId, "adopt", {
+      target_account_id: values["target-account"],
+      motion_id: values.motion
+    }),
+    done: ([rowId]) => `Adopted ${rowId}.`
+  }],
+  ["network-ops ignore", {
+    usage: "audienti network-ops ignore <row_id>",
+    purpose: "Ignore one inbound connection request without accepting or declining it.",
+    api: "POST /api/v1/accounts/:account_id/network_ops/:row_id/ignore.json",
+    run: (client, accountId, [rowId]) => client.networkOpsAction(accountId, rowId, "ignore"),
+    done: ([rowId]) => `Ignored ${rowId}.`
+  }],
+  ["reconciliations add-to-motion", {
+    usage: "audienti reconciliations add-to-motion <source_key> --motion <motion_id>",
+    purpose: "Add one reconciliation candidate to a motion.",
+    api: "POST /api/v1/accounts/:account_id/reconciliations/:id/add_to_motion.json",
+    options: { motion: { type: "string" } },
+    required: ["motion"],
+    run: (client, accountId, [key], values) => client.reconciliationAddToMotion(accountId, key, { motion_id: values.motion }),
+    done: ([key]) => `Added ${key} to the motion.`
+  }],
+  ["reconciliations ignore", {
+    usage: "audienti reconciliations ignore <source_key>",
+    purpose: "Ignore one reconciliation candidate.",
+    api: "POST /api/v1/accounts/:account_id/reconciliations/:id/ignore.json",
+    run: (client, accountId, [key]) => client.reconciliationIgnore(accountId, key),
+    done: ([key]) => `Ignored ${key}.`
+  }],
+  // Motion list bulk actions, strategy retirement, launch checks and premise (#2301).
+  ["motions bulk-add-tag", {
+    usage: "audienti motions bulk-add-tag <motn_id> [<motn_id> ...] --tag <tag>",
+    minPositionals: 1,
+    maxPositionals: Infinity,
+    purpose: "Add one tag to several motions, like Add tag on the motion list. Any motion outside the account fails the whole request.",
+    api: "POST /api/v1/accounts/:account_id/motions/bulk_add_tag.json",
+    options: { tag: { type: "string" } },
+    required: ["tag"],
+    run: (client, accountId, ids, values) => client.bulkAddMotionTag(accountId, { motion_ids: ids, tag: values.tag }),
+    done: (_positionals, payload) => `Tagged ${payload?.length ?? 0} motions.`
+  }],
+  ["motions bulk-remove-tag", {
+    usage: "audienti motions bulk-remove-tag <motn_id> [<motn_id> ...] --tag <tag>",
+    minPositionals: 1,
+    maxPositionals: Infinity,
+    purpose: "Remove one tag from several motions, like Remove tag on the motion list.",
+    api: "POST /api/v1/accounts/:account_id/motions/bulk_remove_tag.json",
+    options: { tag: { type: "string" } },
+    required: ["tag"],
+    run: (client, accountId, ids, values) => client.bulkRemoveMotionTag(accountId, { motion_ids: ids, tag: values.tag }),
+    done: (_positionals, payload) => `Removed the tag from ${payload?.length ?? 0} motions.`
+  }],
+  ["motions bulk-update-principal", {
+    usage: "audienti motions bulk-update-principal <motn_id> [<motn_id> ...] --principal <account_user_id>",
+    minPositionals: 1,
+    maxPositionals: Infinity,
+    purpose: "Give several motions the same owner, like Change owner on the motion list. The owner must be a user in this account.",
+    api: "POST /api/v1/accounts/:account_id/motions/bulk_update_principal.json",
+    options: { principal: { type: "string" } },
+    required: ["principal"],
+    run: (client, accountId, ids, values) => client.bulkUpdateMotionPrincipal(accountId, { motion_ids: ids, principal_account_user_id: values.principal }),
+    done: (_positionals, payload) => `Assigned ${payload?.length ?? 0} motions.`
+  }],
+  ["motions bulk-update-status", {
+    usage: "audienti motions bulk-update-status <motn_id> [<motn_id> ...] --status <preparing|active|closing|paused|archived>",
+    minPositionals: 1,
+    maxPositionals: Infinity,
+    purpose: "Change the status of several motions with the same lifecycle rules as the motion list. Motions the rules block keep their status and are listed with the reason.",
+    api: "POST /api/v1/accounts/:account_id/motions/bulk_update_status.json",
+    options: { status: { type: "string" } },
+    required: ["status"],
+    run: (client, accountId, ids, values) => client.bulkUpdateMotionStatus(accountId, { motion_ids: ids, status: values.status }),
+    done: (_positionals, payload) => [
+      `Set ${payload?.applied_count ?? 0} motions to ${display(payload?.status)}; ${payload?.blocked_count ?? 0} blocked.`,
+      ...(payload?.blocked || []).map((row) => `  ${row.motion_id}: ${display(row.reason)}`)
+    ].join("\n")
+  }],
+  ["motions retire-strategy", {
+    usage: "audienti motions retire-strategy <motn_id> --strategy <strategy_id>",
+    purpose: "Retire one strategy of an inbound motion. Retirement is permanent; the slot refills from the backlog on the next planning pass.",
+    api: "POST /api/v1/accounts/:account_id/motions/:id/strategies/:motion_search_scope_id/retire.json",
+    options: { strategy: { type: "string" } },
+    required: ["strategy"],
+    run: (client, accountId, [id], values) => client.retireMotionStrategy(accountId, id, values.strategy),
+    done: (_positionals, payload) => (payload?.already_retired
+      ? `Strategy ${display(payload?.strategy?.id)} is already retired.`
+      : `Retired strategy ${display(payload?.strategy?.id)}.`)
+  }],
+  ["motions refresh-launch-check", {
+    usage: "audienti motions refresh-launch-check <motn_id>",
+    purpose: "Recheck whether one motion can launch discovery, without starting discovery.",
+    api: "POST /api/v1/accounts/:account_id/motions/:id/refresh_launch_check.json",
+    run: (client, accountId, [id]) => client.refreshMotionLaunchCheck(accountId, id),
+    done: (_positionals, payload) => `${display(payload?.name)}: demand ${display(payload?.demand_status)}, producer ${display(payload?.producer_status)}, reason ${display(payload?.reason)}.`
+  }],
+  ["motions refresh-launch-checks", {
+    usage: "audienti motions refresh-launch-checks",
+    minPositionals: 0,
+    maxPositionals: 0,
+    purpose: "Recheck launch readiness for every motion in the account, without starting discovery.",
+    api: "POST /api/v1/accounts/:account_id/motions/refresh_launch_checks.json",
+    run: (client, accountId) => client.refreshMotionLaunchChecks(accountId),
+    done: (_positionals, payload) => `Launch checks refreshed: ${display(payload?.summary)}.`
+  }],
+  ["motions update-premise", {
+    usage: "audienti motions update-premise <motn_id> --premise <text>",
+    purpose: "Save a motion's premise and rebuild its ICP targeting from it, like Update premise in the Operator.",
+    api: "PATCH /api/v1/accounts/:account_id/motions/:id/update_premise.json",
+    options: { premise: { type: "string" } },
+    required: ["premise"],
+    run: (client, accountId, [id], values) => client.updateMotionPremise(accountId, id, { motion: { premise: values.premise } }),
+    done: ([id]) => `Updated the premise for ${id}.`
+  }]
+]);
+
+for (const [topic, spec] of PARITY_ACTION_COMMANDS) {
+  if (HELP_TOPICS.has(topic)) throw new Error(`duplicate help topic ${topic}`);
+  HELP_TOPICS.set(topic, [
+    "Usage:",
+    `  ${spec.usage} ${ACCOUNT_OPTION_USAGE}`,
+    "",
+    "Status: implemented",
+    "",
+    "Purpose:",
+    `  ${spec.purpose}`,
+    "",
+    "API:",
+    `  ${spec.api}`
+  ].join("\n"));
+}
+
+// List the single-purpose actions under their group help (`audienti help prospects`).
+const parityActionUsagesByGroup = new Map();
+for (const [topic, spec] of PARITY_ACTION_COMMANDS) {
+  const group = topic.split(" ")[0];
+  if (!parityActionUsagesByGroup.has(group)) parityActionUsagesByGroup.set(group, []);
+  parityActionUsagesByGroup.get(group).push(`  ${spec.usage} ${ACCOUNT_OPTION_USAGE}`);
+}
+for (const [group, usages] of parityActionUsagesByGroup) {
+  const section = ["Actions:", ...usages].join("\n");
+  const existing = HELP_TOPICS.get(group);
+  HELP_TOPICS.set(group, existing ? `${existing}\n\n${section}` : section);
+}
+
+function parseJsonObjectOption(raw, flag) {
+  if (raw === undefined) return undefined;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CommandError(`${flag} must be a JSON object, for example '{"selected_action":{"key":"send_email"}}'.`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CommandError(`${flag} must be a JSON object, for example '{"selected_action":{"key":"send_email"}}'.`);
+  }
+  return parsed;
+}
+
+async function runParityActionCommand(topic, args, context, { accountOverride } = {}) {
+  const spec = PARITY_ACTION_COMMANDS.get(topic);
+  const usageLine = `Usage: ${spec.usage} ${ACCOUNT_OPTION_USAGE}`;
+  const { values, positionals } = parseCommandArgs(args, { ...jsonOptions(), ...(spec.options || {}) });
+  const minPositionals = spec.minPositionals ?? 1;
+  const maxPositionals = spec.maxPositionals ?? 1;
+  if (positionals.length < minPositionals || positionals.length > maxPositionals) throw new CommandError(usageLine);
+  if ((spec.required || []).some((key) => !values[key])) throw new CommandError(usageLine);
+
+  const parsedValues = spec.parse ? spec.parse(values, usageLine) : values;
+
+  const { client, accountId } = await requireAccountContext(context, { accountOverride });
+  const payload = await spec.run(client, accountId, positionals, parsedValues);
+  if (values.json) return writeJson(context.stdout, payload);
+
+  writeLine(context.stdout, spec.done(positionals, payload));
+}