superx-cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -118,6 +118,46 @@ var SuperXAPI = class {
     }
     return { status: response.status, headers: response.headers, json };
   }
+  /**
+   * Authenticated request whose 2xx body is NOT JSON (the CSV export). Same
+   * auth, rate-limit capture and error envelope as request(); the difference
+   * is that a successful body comes back as raw text.
+   */
+  async requestText(endpoint, query) {
+    const url = this.buildUrl(endpoint, query);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
+      });
+    } catch (err) {
+      throw new ApiError(0, "network_error", `Could not reach ${this.apiUrl} (${err?.message || err})`);
+    }
+    this.captureRateLimit(response.headers);
+    const text = await response.text();
+    if (!response.ok) {
+      const retryHeader = response.headers.get("retry-after");
+      const retryAfter = retryHeader !== null && Number.isFinite(Number(retryHeader)) ? Number(retryHeader) : null;
+      let code = `http_${response.status}`;
+      let message = `Request failed with HTTP ${response.status}`;
+      let json = null;
+      try {
+        json = text ? JSON.parse(text) : null;
+      } catch {
+        json = null;
+      }
+      const errField = json?.error;
+      if (errField && typeof errField === "object" && typeof errField.code === "string") {
+        code = errField.code;
+        if (typeof errField.message === "string") message = errField.message;
+      } else if (typeof errField === "string") {
+        code = errField.split(":")[0].trim() || code;
+        message = errField;
+      }
+      throw new ApiError(response.status, code, message, retryAfter);
+    }
+    return { text, headers: response.headers };
+  }
   // --- Identity ---
   async me() {
     return (await this.request("/me")).json;
@@ -138,6 +178,32 @@ var SuperXAPI = class {
   async receivedReplies(query = {}) {
     return (await this.request("/replies/received", { query })).json;
   }
+  // --- Drafting ---
+  /** Write post drafts in the account's voice. Nothing is scheduled. */
+  async draftPost(body) {
+    return (await this.request("/posts/draft", { method: "POST", body })).json;
+  }
+  /** Rewrite a post in the account's voice. Nothing is posted or scheduled. */
+  async remixPost(body) {
+    return (await this.request("/posts/remix", { method: "POST", body })).json;
+  }
+  // --- Composer tools (text in, text out; nothing is posted) ---
+  async inlineEdit(body) {
+    return (await this.request("/tools/inline-edit", { method: "POST", body })).json;
+  }
+  async rephrase(body) {
+    return (await this.request("/tools/rephrase", { method: "POST", body })).json;
+  }
+  async factCheck(body) {
+    return (await this.request("/tools/factcheck", { method: "POST", body })).json;
+  }
+  async predictAlgorithm(body) {
+    return (await this.request("/tools/algorithm-predict", { method: "POST", body })).json;
+  }
+  /** Draft ONE reply to a post. Text only: a person posts it. */
+  async draftReply(body) {
+    return (await this.request("/engage/reply-draft", { method: "POST", body })).json;
+  }
   // --- Inspiration ---
   async searchInspiration(query = {}) {
     return (await this.request("/inspiration", { query })).json;
@@ -149,6 +215,28 @@ var SuperXAPI = class {
   async contactReplies(contactId, query = {}) {
     return (await this.request(`/contacts/${encodeURIComponent(contactId)}/replies`, { query })).json;
   }
+  async getContact(contactId, query = {}) {
+    return (await this.request(`/contacts/${encodeURIComponent(contactId)}`, { query })).json;
+  }
+  // --- Contact notes ---
+  async listContactNotes(contactId, query = {}) {
+    return (await this.request(`/contacts/${encodeURIComponent(contactId)}/notes`, { query })).json;
+  }
+  async addContactNote(contactId, body) {
+    return (await this.request(`/contacts/${encodeURIComponent(contactId)}/notes`, { method: "POST", body })).json;
+  }
+  async updateContactNote(contactId, noteId, body) {
+    return (await this.request(
+      `/contacts/${encodeURIComponent(contactId)}/notes/${encodeURIComponent(noteId)}`,
+      { method: "PATCH", body }
+    )).json;
+  }
+  async deleteContactNote(contactId, noteId, query = {}) {
+    return (await this.request(
+      `/contacts/${encodeURIComponent(contactId)}/notes/${encodeURIComponent(noteId)}`,
+      { method: "DELETE", query }
+    )).json;
+  }
   // --- Contact lists ---
   async listContactLists(query = {}) {
     return (await this.request("/contact-lists", { query })).json;
@@ -165,13 +253,44 @@ var SuperXAPI = class {
       { method: "DELETE" }
     )).json;
   }
+  async createList(body) {
+    return (await this.request("/contact-lists", { method: "POST", body })).json;
+  }
+  async renameList(listId, body) {
+    return (await this.request(`/contact-lists/${encodeURIComponent(listId)}`, { method: "PATCH", body })).json;
+  }
+  async deleteList(listId, query = {}) {
+    return (await this.request(`/contact-lists/${encodeURIComponent(listId)}`, { method: "DELETE", query })).json;
+  }
+  async addListMembers(listId, body) {
+    return (await this.request(`/contact-lists/${encodeURIComponent(listId)}/members/bulk`, { method: "POST", body })).json;
+  }
+  async removeListMembers(listId, body) {
+    return (await this.request(`/contact-lists/${encodeURIComponent(listId)}/members/bulk-delete`, { method: "POST", body })).json;
+  }
   // --- Signals ---
   async listSignalAgents(query = {}) {
     return (await this.request("/signals/agents", { query })).json;
   }
+  /** One live keyword search for people on X now. Saves nothing. */
+  async searchLeads(body) {
+    return (await this.request("/signals/leads/search", { method: "POST", body })).json;
+  }
   async listSignalLeads(query = {}) {
     return (await this.request("/signals/leads", { query })).json;
   }
+  /** Audience description -> keyword-watch ideas. Free, creates nothing. */
+  async suggestKeywords(body) {
+    return (await this.request("/signals/keywords/suggest", { method: "POST", body })).json;
+  }
+  /** Audience description -> scoring rubric. Free, creates nothing. */
+  async expandIcp(body) {
+    return (await this.request("/signals/icp/expand", { method: "POST", body })).json;
+  }
+  /** Website -> audience description + rubric + keyword ideas. Free. */
+  async expandIcpFromUrl(body) {
+    return (await this.request("/signals/icp/expand-from-url", { method: "POST", body })).json;
+  }
   async createSignalAgent(body, idempotencyKey) {
     const headers = {};
     if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
@@ -181,9 +300,43 @@ var SuperXAPI = class {
   async setSignalAgentStatus(id, status2) {
     return (await this.request(`/signals/agents/${id}`, { method: "PATCH", body: { status: status2 } })).json;
   }
+  /** Edit an agent's name, ICP, precision mode, destination list or status. */
+  async updateSignalAgent(id, body) {
+    return (await this.request(`/signals/agents/${id}`, { method: "PATCH", body })).json;
+  }
   async deleteSignalAgent(id) {
     return (await this.request(`/signals/agents/${id}`, { method: "DELETE" })).json;
   }
+  async addSignalAgentSignal(id, body) {
+    return (await this.request(`/signals/agents/${id}/signals`, { method: "POST", body })).json;
+  }
+  async removeSignalAgentSignal(id, signalId) {
+    return (await this.request(`/signals/agents/${id}/signals/${signalId}`, { method: "DELETE" })).json;
+  }
+  /** Record (or clear, with null) the verdict on one lead. */
+  async setLeadFeedback(leadId, body) {
+    return (await this.request(`/signals/leads/${leadId}/feedback`, { method: "POST", body })).json;
+  }
+  // --- Workers ---
+  async listWorkers(query = {}) {
+    return (await this.request("/workers", { query })).json;
+  }
+  /** The posts your Workers have written, newest first. */
+  async listWorkerSuggestions(query = {}) {
+    return (await this.request("/workers/suggestions", { query })).json;
+  }
+  /** Save one suggestion as a draft. Nothing is posted. */
+  async draftWorkerSuggestion(id, body) {
+    return (await this.request(`/workers/suggestions/${id}/draft`, { method: "POST", body })).json;
+  }
+  /** Save one suggestion as a scheduled post. */
+  async scheduleWorkerSuggestion(id, body) {
+    return (await this.request(`/workers/suggestions/${id}/schedule`, { method: "POST", body })).json;
+  }
+  /** Clear one suggestion out of the To review list. */
+  async dismissWorkerSuggestion(id, body) {
+    return (await this.request(`/workers/suggestions/${id}/dismiss`, { method: "POST", body })).json;
+  }
   // --- Engage ---
   async listEngageFeeds(query = {}) {
     return (await this.request("/engage/feeds", { query })).json;
@@ -191,6 +344,15 @@ var SuperXAPI = class {
   async getEngageFeedPosts(feedId, query = {}) {
     return (await this.request(`/engage/feeds/${encodeURIComponent(feedId)}/posts`, { query })).json;
   }
+  async createEngageFeed(body) {
+    return (await this.request("/engage/feeds", { method: "POST", body })).json;
+  }
+  async updateEngageFeed(feedId, body) {
+    return (await this.request(`/engage/feeds/${encodeURIComponent(feedId)}`, { method: "PATCH", body })).json;
+  }
+  async deleteEngageFeed(feedId, query = {}) {
+    return (await this.request(`/engage/feeds/${encodeURIComponent(feedId)}`, { method: "DELETE", query })).json;
+  }
   // --- Scheduled posts ---
   async listScheduled(query = {}) {
     return (await this.request("/scheduled-posts", { query })).json;
@@ -201,6 +363,29 @@ var SuperXAPI = class {
     const res = await this.request("/scheduled-posts", { method: "POST", body, headers });
     return { json: res.json, replayed: res.headers.get("idempotency-replayed") === "true" };
   }
+  /**
+   * Publish immediately: the create endpoint with scheduled_for "now". The
+   * Idempotency-Key is REQUIRED by the API (a retry must never post twice),
+   * so it is a plain parameter here rather than an optional one.
+   */
+  async publishNow(body, idempotencyKey) {
+    const res = await this.request("/scheduled-posts", {
+      method: "POST",
+      body,
+      headers: { "Idempotency-Key": idempotencyKey }
+    });
+    return { json: res.json, replayed: res.headers.get("idempotency-replayed") === "true" };
+  }
+  // --- Scheduled posts: bulk queue operations ---
+  async bulkRetimeScheduled(body) {
+    return (await this.request("/scheduled-posts/bulk/retime", { method: "POST", body })).json;
+  }
+  async bulkEnableAutoRetweet(body) {
+    return (await this.request("/scheduled-posts/bulk/auto-retweet", { method: "POST", body })).json;
+  }
+  async bulkDeleteScheduled(body) {
+    return (await this.request("/scheduled-posts/bulk/delete", { method: "POST", body })).json;
+  }
   async updateScheduled(id, body) {
     return (await this.request(`/scheduled-posts/${encodeURIComponent(id)}`, { method: "PATCH", body })).json;
   }
@@ -224,6 +409,21 @@ var SuperXAPI = class {
   async deleteContextProduct(id, query = {}) {
     return (await this.request(`/context/products/${encodeURIComponent(id)}`, { method: "DELETE", query })).json;
   }
+  /** Full replace of the account's product list (max 5). */
+  async setContextProducts(body) {
+    return (await this.request("/context/products", { method: "PUT", body })).json;
+  }
+  /** Rebuild the generated style guide from recent posts. Free, once an hour. */
+  async regenerateStyleGuide(body) {
+    return (await this.request("/context/style-guide/regenerate", { method: "POST", body })).json;
+  }
+  /** Re-read a saved product's page and refresh its stored details. Free. */
+  async scrapeContextProduct(id, body) {
+    return (await this.request(`/context/products/${encodeURIComponent(id)}/scrape`, {
+      method: "POST",
+      body
+    })).json;
+  }
   // --- Queue settings ---
   async getQueueSettings(query = {}) {
     return (await this.request("/queue-settings", { query })).json;
@@ -276,6 +476,99 @@ var SuperXAPI = class {
   async generateArticleCover(id, body) {
     return (await this.request(`/articles/${encodeURIComponent(id)}/cover`, { method: "POST", body })).json;
   }
+  /** Saved article cover styles (pass an id as style_id to the cover call). */
+  async listCoverStyles(query = {}) {
+    return (await this.request("/cover-styles", { query })).json;
+  }
+  // --- Datasets (Ask SuperX collections) ---
+  async listDatasets(query = {}) {
+    return (await this.request("/datasets", { query })).json;
+  }
+  async getDataset(id) {
+    return (await this.request(`/datasets/${encodeURIComponent(id)}`)).json;
+  }
+  async getDatasetRows(id, query = {}) {
+    return (await this.request(`/datasets/${encodeURIComponent(id)}/rows`, { query })).json;
+  }
+  /** CSV export. Raw text, with the server's filename from Content-Disposition. */
+  async exportDatasetCsv(id) {
+    const { text, headers } = await this.requestText(
+      `/datasets/${encodeURIComponent(id)}/export`,
+      { format: "csv" }
+    );
+    const disposition = headers.get("content-disposition") || "";
+    const match = /filename="([^"]+)"/.exec(disposition);
+    return { filename: match ? match[1] : `superx-dataset-${id}.csv`, text };
+  }
+  async addDatasetToList(id, body) {
+    return (await this.request(`/datasets/${encodeURIComponent(id)}/contacts`, { method: "POST", body })).json;
+  }
+  /** Start a collection. Answers a ready dataset, or a collecting one (202). */
+  async createDataset(body) {
+    return (await this.request("/datasets", { method: "POST", body })).json;
+  }
+  /** Draft one outreach message per row of a research dataset. Text only. */
+  async draftOutreachDms(id, body) {
+    return (await this.request(`/datasets/${encodeURIComponent(id)}/outreach-drafts`, {
+      method: "POST",
+      body
+    })).json;
+  }
+  /** Filter a dataset by each row's text into a NEW dataset (200 or 202). */
+  async refineDataset(id, body) {
+    return (await this.request(`/datasets/${encodeURIComponent(id)}/refine`, {
+      method: "POST",
+      body
+    })).json;
+  }
+  // --- Audience (the four system people-lists) ---
+  /** kind: followers | following | repliers | reposters. Cursor paging. */
+  async getAudience(kind, query = {}) {
+    return (await this.request(`/audience/${encodeURIComponent(kind)}`, { query })).json;
+  }
+  /** Posts @-mentioning the account, read live. Costs 3 feed fetches. */
+  async getMentions(query = {}) {
+    return (await this.request("/engage/mentions", { query })).json;
+  }
+  // --- Live X lookups (read X now, not SuperX's stored data) ---
+  async lookupXPost(id, query = {}) {
+    return (await this.request(`/x/posts/${encodeURIComponent(id)}`, { query })).json;
+  }
+  async getXPostReplies(id, query = {}) {
+    return (await this.request(`/x/posts/${encodeURIComponent(id)}/replies`, { query })).json;
+  }
+  async lookupXUser(handle) {
+    return (await this.request(`/x/users/${encodeURIComponent(handle)}`)).json;
+  }
+  async getXUserPosts(handle, query = {}) {
+    return (await this.request(`/x/users/${encodeURIComponent(handle)}/posts`, { query })).json;
+  }
+  // --- Inspiration media (cross-platform media index) ---
+  async searchInspirationMedia(query = {}) {
+    return (await this.request("/inspiration/media", { query })).json;
+  }
+  // --- DM campaigns (enqueue only: the SuperX app sends) ---
+  async queueDmCampaign(body, idempotencyKey) {
+    const headers = {};
+    if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
+    const res = await this.request("/dm/campaigns", { method: "POST", body, headers });
+    return { json: res.json, replayed: res.headers.get("idempotency-replayed") === "true" };
+  }
+  async getDmCampaign(id, query = {}) {
+    return (await this.request(`/dm/campaigns/${encodeURIComponent(id)}`, { query })).json;
+  }
+  async cancelDmCampaign(id, query = {}) {
+    return (await this.request(`/dm/campaigns/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      query
+    })).json;
+  }
+  async listDmQueue(query = {}) {
+    return (await this.request("/dm/queue", { query })).json;
+  }
+  async getDmLimits(query = {}) {
+    return (await this.request("/dm/limits", { query })).json;
+  }
   // --- Docs (unauthenticated markdown) ---
   async docs() {
     const url = this.buildUrl("/docs");
@@ -412,6 +705,7 @@ async function status() {
     api_url: config.apiUrl,
     owner: me2?.data?.owner ?? null,
     plan: me2?.data?.plan ?? null,
+    credits: me2?.data?.credits ?? null,
     key: me2?.data?.key ?? null,
     rate_limit: api.lastRateLimit
   });
@@ -452,6 +746,24 @@ async function postsAnalytics(argv) {
     })
   );
 }
+async function postsDraft(argv) {
+  if (!argv.brief || !argv.brief.trim()) {
+    note('Provide --brief "what the post should say".');
+    process.exit(1);
+  }
+  const body = { brief: argv.brief };
+  if (argv.count !== void 0) body.count = argv.count;
+  if (argv.voice) body.voice = argv.voice;
+  if (argv.creator) body.creator = argv.creator;
+  if (argv.mirror) body.mirror = argv.mirror;
+  if (argv.collection) body.collection = argv.collection;
+  if (argv.instructions) body.instructions = argv.instructions;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  const json = await api.draftPost(body);
+  note("Nothing was scheduled. Review the text, then pass it to scheduled:create.");
+  printJson(json);
+}
 async function repliesList(argv) {
   const api = new SuperXAPI(getConfig());
   printJson(
@@ -477,6 +789,49 @@ async function repliesReceived(argv) {
     })
   );
 }
+async function postsRemix(argv) {
+  const body = {
+    text: argv.text,
+    closeness: argv.closeness
+  };
+  if (argv.instructions) body.instructions = argv.instructions;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.remixPost(body));
+}
+
+// src/commands/tools.ts
+async function toolsInlineEdit(argv) {
+  if (!argv.instruction && !argv.type) {
+    note('Provide --instruction "..." or --type <preset> (or both).');
+    process.exit(1);
+  }
+  const body = { text: argv.text };
+  if (argv.full) body.full_text = argv.full;
+  if (argv.instruction) body.instruction = argv.instruction;
+  if (argv.type) body.edit_type = argv.type;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.inlineEdit(body));
+}
+async function toolsRephrase(argv) {
+  const body = { type: argv.type, text: argv.text };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.rephrase(body));
+}
+async function toolsFactcheck(argv) {
+  const body = { text: argv.text };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.factCheck(body));
+}
+async function toolsPredict(argv) {
+  const body = { version_a: argv.a, version_b: argv.b };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.predictAlgorithm(body));
+}
 
 // src/commands/inspiration.ts
 async function inspirationSearch(argv) {
@@ -501,6 +856,70 @@ async function inspirationSearch(argv) {
     })
   );
 }
+async function inspirationMedia(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.searchInspirationMedia({
+      q: argv.query,
+      platforms: argv.platforms,
+      time_filter: argv.timeFilter,
+      media_type: argv.mediaType,
+      content_type: argv.contentType,
+      limit: argv.limit
+    })
+  );
+}
+
+// src/commands/x.ts
+function toPostId(ref) {
+  const s = String(ref || "").trim();
+  if (/^\d{1,25}$/.test(s)) return s;
+  const m = s.match(
+    /^https?:\/\/(?:www\.|mobile\.)?(?:x\.com|twitter\.com)\/[A-Za-z0-9_]+\/status(?:es)?\/(\d+)/i
+  );
+  if (m) return m[1];
+  throw new ApiError(
+    0,
+    "invalid_parameter",
+    "Provide an x.com/twitter.com post URL or a bare numeric post id."
+  );
+}
+function toHandle(raw) {
+  const s = String(raw || "").trim().replace(/^@/, "");
+  if (!/^[A-Za-z0-9_]{1,15}$/.test(s)) {
+    throw new ApiError(
+      0,
+      "invalid_parameter",
+      "Provide a valid X handle: 1-15 letters, numbers or underscores."
+    );
+  }
+  return s;
+}
+async function xPost(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.lookupXPost(toPostId(argv.id), {
+      include_quotes: argv.quotes ? "true" : void 0
+    })
+  );
+}
+async function xReplies(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.getXPostReplies(toPostId(argv.id), { limit: argv.limit }));
+}
+async function xUser(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.lookupXUser(toHandle(argv.handle)));
+}
+async function xUserPosts(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.getXUserPosts(toHandle(argv.handle), {
+      limit: argv.limit,
+      exclude_reposts: argv.reposts === false ? "true" : void 0
+    })
+  );
+}
 
 // src/commands/contacts.ts
 async function contactsList(argv) {
@@ -525,6 +944,38 @@ async function contactsReplies(argv) {
     })
   );
 }
+async function contactsGet(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.getContact(argv.id, {
+      account_id: argv.account,
+      // Only send the flag when asked: the default read is cache-only and
+      // costs no enrichment.
+      refresh: argv.refresh ? "true" : void 0
+    })
+  );
+}
+async function contactsNotes(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.listContactNotes(argv.id, { account_id: argv.account }));
+}
+async function contactsNotesAdd(argv) {
+  const body = { body: argv.body };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.addContactNote(argv.id, body));
+}
+async function contactsNotesUpdate(argv) {
+  const body = { body: argv.body };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.updateContactNote(argv.id, argv.noteId, body));
+}
+async function contactsNotesDelete(argv) {
+  const api = new SuperXAPI(getConfig());
+  await api.deleteContactNote(argv.id, argv.noteId, { account_id: argv.account });
+  printJson({ data: { id: argv.noteId, deleted: true } });
+}
 
 // src/commands/lists.ts
 async function listsList(argv) {
@@ -555,6 +1006,181 @@ async function listsRemoveMember(argv) {
   await api.removeListMember(argv.id, argv.memberId);
   printJson({ data: { id: argv.memberId, removed: true } });
 }
+async function listsCreate(argv) {
+  const body = { name: argv.name };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.createList(body));
+}
+async function listsRename(argv) {
+  const body = { name: argv.name };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.renameList(argv.id, body));
+}
+async function listsDelete(argv) {
+  const api = new SuperXAPI(getConfig());
+  await api.deleteList(argv.id, { account_id: argv.account });
+  printJson({ data: { id: argv.id, deleted: true } });
+}
+function commaList(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function listsAddMembers(argv) {
+  const ids = commaList(argv.xUserIds || "");
+  if (ids.length === 0) {
+    note("Provide at least one id: --x-user-ids 44196397,1234567890");
+    process.exit(1);
+  }
+  const body = { x_user_ids: ids };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.addListMembers(argv.id, body));
+}
+async function listsRemoveMembers(argv) {
+  const ids = commaList(argv.memberIds || "");
+  if (ids.length === 0) {
+    note("Provide at least one id: --member-ids abc123,def456");
+    process.exit(1);
+  }
+  const body = { member_ids: ids };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.removeListMembers(argv.id, body));
+}
+
+// src/commands/datasets.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+async function datasetsList(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.listDatasets({ limit: argv.limit, page: argv.page }));
+}
+async function datasetsGet(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.getDataset(argv.id));
+}
+async function datasetsRows(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.getDatasetRows(argv.id, { limit: argv.limit, page: argv.page })
+  );
+}
+async function datasetsExport(argv) {
+  const api = new SuperXAPI(getConfig());
+  const { filename, text } = await api.exportDatasetCsv(argv.id);
+  if (argv.out === "-") {
+    process.stdout.write(text);
+    return;
+  }
+  const target = argv.out ? argv.out : import_path.default.join(process.cwd(), import_path.default.basename(filename));
+  import_fs.default.writeFileSync(target, text, "utf8");
+  note(`Wrote ${target}`);
+  printJson({ file: target, bytes: Buffer.byteLength(text, "utf8") });
+}
+async function datasetsAddToList(argv) {
+  const body = { list_id: argv.listId };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.addDatasetToList(argv.id, body));
+}
+var WAIT_POLL_MS = 5e3;
+var WAIT_TIMEOUT_MS = 15 * 60 * 1e3;
+async function waitForDataset(api, started) {
+  const datasetId = started?.data?.id;
+  if (!datasetId || started?.data?.status !== "collecting") return false;
+  note(`Running ${datasetId}; polling every ${WAIT_POLL_MS / 1e3}s until it is ready.`);
+  const deadline = Date.now() + WAIT_TIMEOUT_MS;
+  let latest = started;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, WAIT_POLL_MS));
+    latest = await api.getDataset(datasetId);
+    if (latest?.data?.status !== "collecting") {
+      printJson(latest);
+      return true;
+    }
+  }
+  note("Still running after 15 minutes; giving up on waiting (the job keeps going).");
+  printJson(latest);
+  return true;
+}
+async function datasetsCollect(argv) {
+  const splitList = (raw) => raw === void 0 ? void 0 : raw.split(",").map((k) => k.trim()).filter(Boolean);
+  const filters = {};
+  const keywords = splitList(argv.keywords);
+  if (keywords) filters.keywords = keywords;
+  const bioKeywords = splitList(argv.bioKeywords);
+  if (bioKeywords) filters.bio_keywords = bioKeywords;
+  if (argv.minFollowers !== void 0) filters.min_followers = argv.minFollowers;
+  if (argv.requireWebsite !== void 0) filters.require_website = argv.requireWebsite;
+  if (argv.requireCanDm !== void 0) filters.require_can_dm = argv.requireCanDm;
+  if (argv.sinceDays !== void 0) filters.since_days = argv.sinceDays;
+  if (argv.sort !== void 0) filters.sort = argv.sort;
+  const body = { source: argv.source };
+  if (argv.target) body.target = argv.target;
+  if (argv.title) body.title = argv.title;
+  if (argv.maxRows !== void 0) body.max_rows = argv.maxRows;
+  if (argv.account) body.account_id = argv.account;
+  if (Object.keys(filters).length > 0) body.filters = filters;
+  const api = new SuperXAPI(getConfig());
+  const started = await api.createDataset(body);
+  if (argv.wait && await waitForDataset(api, started)) return;
+  printJson(started);
+}
+async function datasetsResearch(argv) {
+  const body = { source: "research" };
+  if (argv.handles !== void 0) {
+    body.handles = argv.handles.split(",").map((h) => h.trim()).filter(Boolean);
+  }
+  if (argv.list) body.list_id = argv.list;
+  if (argv.agent !== void 0) body.agent_id = argv.agent;
+  if (argv.dataset) body.dataset_id = argv.dataset;
+  if (argv.max !== void 0) body.max_rows = argv.max;
+  if (argv.focus) body.focus = argv.focus;
+  if (argv.title) body.title = argv.title;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  const started = await api.createDataset(body);
+  if (argv.wait && await waitForDataset(api, started)) return;
+  printJson(started);
+}
+async function datasetsOutreachDrafts(argv) {
+  const body = { format: argv.format };
+  if (argv.instructions) body.instructions = argv.instructions;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.draftOutreachDms(argv.id, body));
+}
+async function datasetsRefine(argv) {
+  const body = { criterion: argv.criterion };
+  if (argv.keep !== void 0) body.keep_matching = argv.keep;
+  if (argv.sort) body.sort_by = argv.sort;
+  if (argv.limit !== void 0) body.limit = argv.limit;
+  if (argv.title) body.title = argv.title;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  const started = await api.refineDataset(argv.id, body);
+  if (argv.wait && await waitForDataset(api, started)) return;
+  printJson(started);
+}
+
+// src/commands/audience.ts
+var KINDS = ["followers", "following", "repliers", "reposters"];
+async function audienceList(argv) {
+  const kind = String(argv.kind || "").trim();
+  if (!KINDS.includes(kind)) {
+    note(`kind must be one of: ${KINDS.join(", ")}`);
+    process.exit(1);
+  }
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.getAudience(kind, {
+      account_id: argv.account,
+      cursor: argv.cursor,
+      limit: argv.limit
+    })
+  );
+}
 
 // src/commands/signals.ts
 async function signalsAgents(argv) {
@@ -576,6 +1202,17 @@ async function signalsLeads(argv) {
     })
   );
 }
+async function signalsSearch(argv) {
+  const body = {
+    keywords: argv.keywords,
+    icp_description: argv.icp
+  };
+  if (argv.precision) body.precision = argv.precision;
+  if (argv.max !== void 0) body.max_leads = argv.max;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.searchLeads(body));
+}
 async function signalsCreateAgent(argv) {
   const body = {
     name: argv.name,
@@ -585,6 +1222,8 @@ async function signalsCreateAgent(argv) {
   if (argv["list-id"]) body.destination_list_id = argv["list-id"];
   const keywords = (argv.keyword || []).filter((k) => typeof k === "string" && k.length > 0);
   if (keywords.length > 0) body.keywords = keywords;
+  const specs = (argv.signal || []).filter((s) => typeof s === "string" && s.length > 0);
+  if (specs.length > 0) body.signals = specs.map(parseSignalSpec);
   const api = new SuperXAPI(getConfig());
   const { json, replayed } = await api.createSignalAgent(body, argv["idempotency-key"]);
   if (replayed) {
@@ -606,6 +1245,139 @@ async function signalsDeleteAgent(argv) {
   const api = new SuperXAPI(getConfig());
   printJson(await api.deleteSignalAgent(argv.id));
 }
+var SIGNAL_TYPE_ALIASES = {
+  keyword: "keyword_watch",
+  keyword_watch: "keyword_watch",
+  profile: "profile_watch",
+  profile_watch: "profile_watch",
+  follower: "follower_watch",
+  follower_watch: "follower_watch",
+  list: "list_watch",
+  list_watch: "list_watch"
+};
+function parseSignalSpec(spec) {
+  const at = spec.indexOf(":");
+  const rawType = at === -1 ? "" : spec.slice(0, at).trim().toLowerCase();
+  const target = at === -1 ? "" : spec.slice(at + 1).trim();
+  const type = SIGNAL_TYPE_ALIASES[rawType];
+  if (!type || !target) {
+    note(
+      `Could not read --signal "${spec}". Use type:target, for example keyword:"just shipped my MVP", profile:@naval, follower:@naval or list:https://x.com/i/lists/123.`
+    );
+    process.exit(1);
+  }
+  if (type === "keyword_watch") return { type, query: target };
+  if (type === "list_watch") return { type, list: target };
+  return { type, handle: target };
+}
+async function signalsUpdateAgent(argv) {
+  const body = {};
+  if (argv.name !== void 0) body.name = argv.name;
+  if (argv.icp !== void 0) body.icp_description = argv.icp;
+  if (argv.precision !== void 0) body.precision_mode = argv.precision;
+  if (argv["list-id"] !== void 0) body.destination_list_id = argv["list-id"];
+  if (argv.status !== void 0) body.status = argv.status;
+  if (Object.keys(body).length === 0) {
+    note("Provide at least one of: --name, --icp, --precision, --list-id, --status.");
+    process.exit(1);
+  }
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.updateSignalAgent(argv.id, body));
+}
+async function signalsAddSignal(argv) {
+  const type = SIGNAL_TYPE_ALIASES[String(argv.type || "").toLowerCase()];
+  if (!type) {
+    note("--type must be one of: keyword_watch, profile_watch, follower_watch, list_watch.");
+    process.exit(1);
+  }
+  const body = { type };
+  if (argv.query !== void 0) body.query = argv.query;
+  if (argv.handle !== void 0) body.handle = argv.handle;
+  if (argv.list !== void 0) body.list = argv.list;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.addSignalAgentSignal(argv.id, body));
+}
+async function signalsRemoveSignal(argv) {
+  const api = new SuperXAPI(getConfig());
+  await api.removeSignalAgentSignal(argv.id, argv.signalId);
+  printJson({ agent_id: argv.id, signal_id: argv.signalId, deleted: true });
+}
+async function signalsFeedback(argv) {
+  const chosen = [argv.fit, argv["not-fit"], argv.clear].filter(Boolean);
+  if (chosen.length !== 1) {
+    note("Pass exactly one of --fit, --not-fit or --clear.");
+    process.exit(1);
+  }
+  const feedback = argv.fit ? "fit" : argv["not-fit"] ? "not_fit" : null;
+  const body = { feedback };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.setLeadFeedback(argv.leadId, body));
+}
+async function signalsSuggestKeywords(argv) {
+  const body = { icp_description: argv.icp };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.suggestKeywords(body));
+}
+async function signalsExpandIcp(argv) {
+  const text = (argv.text || "").trim();
+  const url = (argv.url || "").trim();
+  if (!text && !url) {
+    note("Provide --text with an audience description, or --url with a website.");
+    process.exit(1);
+  }
+  if (text && url) {
+    note("Use either --text or --url, not both.");
+    process.exit(1);
+  }
+  const body = url ? { url } : { icp_description: text };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(url ? await api.expandIcpFromUrl(body) : await api.expandIcp(body));
+}
+
+// src/commands/workers.ts
+async function workersList(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.listWorkers({ account_id: argv.account }));
+}
+async function workersSuggestions(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.listWorkerSuggestions({
+      account_id: argv.account,
+      status: argv.status,
+      worker_id: argv.worker,
+      limit: argv.limit,
+      page: argv.page
+    })
+  );
+}
+async function workersDraft(argv) {
+  const body = {};
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.draftWorkerSuggestion(argv.id, body));
+}
+async function workersSchedule(argv) {
+  if (typeof argv.at !== "string" || argv.at.length === 0) {
+    note("--at is required: the UTC ISO-8601 time to post, for example 2026-09-15T14:00:00Z.");
+    process.exit(1);
+    return;
+  }
+  const body = { scheduled_for: argv.at };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.scheduleWorkerSuggestion(argv.id, body));
+}
+async function workersDismiss(argv) {
+  const body = {};
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.dismissWorkerSuggestion(argv.id, body));
+}
 
 // src/commands/engage.ts
 async function engageFeeds(argv) {
@@ -626,6 +1398,89 @@ async function engagePosts(argv) {
     })
   );
 }
+function feedSourceBody(argv) {
+  const keywords = (argv.keyword || []).filter(
+    (k) => typeof k === "string" && k.length > 0
+  );
+  const families = [
+    keywords.length > 0 ? "keywords" : null,
+    argv["x-list"] ? "x_list" : null,
+    argv["list-id"] ? "list" : null
+  ].filter(Boolean);
+  if (families.length === 0) return null;
+  if (families.length > 1) {
+    note("Use exactly one source: --keyword, --x-list or --list-id.");
+    process.exit(1);
+  }
+  if (keywords.length > 0) return { type: "keywords", keywords };
+  if (argv["x-list"]) {
+    const raw = String(argv["x-list"]).trim();
+    return /^\d{1,32}$/.test(raw) ? { type: "x_list", x_list_id: raw } : { type: "x_list", x_list_url: raw };
+  }
+  return { type: "list", list_id: argv["list-id"] };
+}
+async function engageFeedsCreate(argv) {
+  const source = feedSourceBody(argv);
+  if (!source) {
+    note("Provide a source: --keyword (repeatable), --x-list or --list-id.");
+    process.exit(1);
+  }
+  const body = { name: argv.name, ...source };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.createEngageFeed(body));
+}
+async function engageFeedsUpdate(argv) {
+  const source = feedSourceBody(argv);
+  const body = { ...source || {} };
+  delete body.type;
+  if (argv.name !== void 0) body.name = argv.name;
+  if (Object.keys(body).length === 0) {
+    note("Provide --name, or a new source: --keyword, --x-list or --list-id.");
+    process.exit(1);
+  }
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.updateEngageFeed(argv.feedId, body));
+}
+async function engageFeedsDelete(argv) {
+  const api = new SuperXAPI(getConfig());
+  await api.deleteEngageFeed(argv.feedId, { account_id: argv.account });
+  printJson({ id: argv.feedId, deleted: true });
+}
+async function engageMentions(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.getMentions({
+      account_id: argv.account,
+      sort: argv.sort,
+      // yargs boolean: pass through only when the flag was given.
+      include_replied: argv.includeReplied === void 0 ? void 0 : String(argv.includeReplied),
+      cursor: argv.cursor
+    })
+  );
+}
+async function engageReplyDraft(argv) {
+  const hasPost = !!argv.post;
+  const hasText = !!argv.text;
+  if (hasPost === hasText) {
+    note('Provide exactly one of --post <id> (read live) or --text "the post".');
+    process.exit(1);
+  }
+  const body = {};
+  if (hasPost) body.post_id = argv.post;
+  else {
+    const post = { text: argv.text };
+    if (argv.author) post.author_name = argv.author;
+    if (argv.handle) post.author_handle = argv.handle;
+    body.post = post;
+  }
+  if (argv.thoughts) body.thoughts = argv.thoughts;
+  if (argv.tone) body.tone = argv.tone;
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.draftReply(body));
+}
 
 // src/commands/scheduled.ts
 async function scheduledList(argv) {
@@ -745,6 +1600,40 @@ function applyAdvancedFlags(argv, body) {
     note("--auto-plug-threshold requires --auto-plug <templateId>.");
     process.exit(1);
   }
+  const dmMessage = argv["auto-dm-message"];
+  const dmTriggers = argv["auto-dm-triggers"];
+  const dmMax = numericFlag("auto-dm-max", argv["auto-dm-max"]);
+  const dmBatch = argv["auto-dm-batch"];
+  const dmOff = argv["auto-dm"] === false;
+  if (dmOff) {
+    if (dmMessage !== void 0 || dmTriggers !== void 0 || typeof dmMax === "number" || dmBatch !== void 0) {
+      note("--auto-dm-* flags cannot be combined with --no-auto-dm.");
+      process.exit(1);
+    }
+    body.auto_dm = null;
+  } else if (typeof dmMessage === "string" && dmMessage.length > 0) {
+    const autoDm = { message: dmMessage };
+    if (typeof dmTriggers === "string") {
+      const wanted = dmTriggers.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+      const unknown = wanted.filter(
+        (t) => t !== "reply" && t !== "repost" && t !== "retweet"
+      );
+      if (unknown.length > 0 || wanted.length === 0) {
+        note("--auto-dm-triggers takes a comma list of reply,repost (retweet is accepted as an alias of repost).");
+        process.exit(1);
+      }
+      autoDm.triggers = {
+        reply: wanted.includes("reply"),
+        repost: wanted.includes("repost") || wanted.includes("retweet")
+      };
+    }
+    if (typeof dmMax === "number") autoDm.max_dms = dmMax;
+    if (typeof dmBatch === "boolean") autoDm.batch_mode = dmBatch;
+    body.auto_dm = autoDm;
+  } else if (dmTriggers !== void 0 || typeof dmMax === "number" || dmBatch !== void 0) {
+    note("--auto-dm-triggers, --auto-dm-max and --auto-dm-batch require --auto-dm-message <text>.");
+    process.exit(1);
+  }
   if (typeof argv["super-followers"] === "boolean") {
     body.super_followers_only = argv["super-followers"];
   }
@@ -859,10 +1748,118 @@ async function scheduledDelete(argv) {
   const api = new SuperXAPI(getConfig());
   printJson(await api.deleteScheduled(argv.id));
 }
+async function postsPublish(argv) {
+  const idempotencyKey = argv["idempotency-key"];
+  if (typeof idempotencyKey !== "string" || idempotencyKey.length === 0) {
+    note("--idempotency-key is required for posts:publish. Reuse the SAME key when retrying; only use a new key for new content.");
+    process.exit(1);
+    return;
+  }
+  const parts = (argv.part || []).filter((p) => typeof p === "string");
+  const sourceCount = [argv.text, parts.length > 0 ? "p" : void 0, argv["parts-json"]].filter(
+    (v) => v !== void 0
+  ).length;
+  if (sourceCount > 1) {
+    note("Use exactly one of --text (single post), --part (thread), or --parts-json.");
+    process.exit(1);
+  }
+  if (sourceCount === 0) {
+    note("Provide --text for a single post, --part flags for a thread, or --parts-json.");
+    process.exit(1);
+  }
+  if (argv.media !== void 0 && !argv.text) {
+    note("--media applies to the --text single-post form. For threads, put media in --parts-json.");
+    process.exit(1);
+  }
+  const body = { scheduled_for: "now" };
+  if (argv["parts-json"] !== void 0) {
+    body.parts = parsePartsJson(argv["parts-json"]);
+  } else if (argv.text) {
+    const media = mediaFromFlags(argv.media, argv["alt-text"]);
+    if (media) {
+      body.parts = [{ text: argv.text, media }];
+    } else {
+      body.text = argv.text;
+    }
+  } else {
+    body.parts = parts.map((text) => ({ text }));
+  }
+  const tags = (argv.tag || []).filter((t) => typeof t === "string" && t.length > 0);
+  if (tags.length > 0) body.tags = tags;
+  applyAdvancedFlags(argv, body);
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  const { json, replayed } = await api.publishNow(body, idempotencyKey);
+  if (replayed) {
+    note("Idempotency replay: this key was already published; returning the original result. Nothing was posted twice.");
+    printJson({ ...json, replayed: true });
+    return;
+  }
+  printJson(json);
+}
+function idsFromFlag(name, raw) {
+  const ids = (raw || "").split(",").map((id) => id.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    note(`--${name} must be a comma list of post ids (from scheduled:list).`);
+    process.exit(1);
+  }
+  return Array.from(new Set(ids));
+}
+async function scheduledBulkRetime(argv) {
+  const raw = argv["moves-json"];
+  if (typeof raw !== "string" || raw.length === 0) {
+    note(`--moves-json is required, e.g. '[{"id":"abc","scheduled_for":"2026-09-08T15:00:00Z"}]'`);
+    process.exit(1);
+    return;
+  }
+  let moves;
+  try {
+    moves = JSON.parse(raw);
+  } catch {
+    note(`--moves-json must be valid JSON, e.g. '[{"id":"abc","scheduled_for":"2026-09-08T15:00:00Z"}]'`);
+    process.exit(1);
+    return;
+  }
+  if (!Array.isArray(moves) || moves.length === 0 || moves.some((m) => !m || typeof m !== "object" || typeof m.id !== "string" || typeof m.scheduled_for !== "string")) {
+    note("--moves-json must be a non-empty array of { id, scheduled_for } objects.");
+    process.exit(1);
+  }
+  const body = { moves };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.bulkRetimeScheduled(body));
+}
+async function scheduledBulkAutoRetweet(argv) {
+  const ids = idsFromFlag("ids", argv.ids);
+  const afterHours = numericFlag("auto-retweet", argv["auto-retweet"]);
+  if (typeof afterHours !== "number") {
+    note("--auto-retweet <hours> is required (1-12).");
+    process.exit(1);
+    return;
+  }
+  const removeAfterHours = numericFlag("auto-retweet-remove", argv["auto-retweet-remove"]);
+  const body = {
+    ids,
+    auto_retweet: {
+      after_hours: afterHours,
+      ...typeof removeAfterHours === "number" ? { remove_after_hours: removeAfterHours } : {}
+    }
+  };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.bulkEnableAutoRetweet(body));
+}
+async function scheduledBulkDelete(argv) {
+  const ids = idsFromFlag("ids", argv.ids);
+  const body = { ids };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.bulkDeleteScheduled(body));
+}
 
 // src/commands/media.ts
-var import_fs = require("fs");
-var import_path = __toESM(require("path"));
+var import_fs2 = require("fs");
+var import_path2 = __toESM(require("path"));
 function sniffImageType(bytes) {
   if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
     return "image/jpeg";
@@ -888,19 +1885,19 @@ var EXT_TYPES = {
 async function mediaUpload(argv) {
   let buffer;
   try {
-    buffer = (0, import_fs.readFileSync)(argv.file);
+    buffer = (0, import_fs2.readFileSync)(argv.file);
   } catch (err) {
     note(`Error: could not read ${argv.file} (${err?.message || err})`);
     process.exit(1);
     return;
   }
-  const fileType = sniffImageType(buffer) || EXT_TYPES[import_path.default.extname(argv.file).toLowerCase()];
+  const fileType = sniffImageType(buffer) || EXT_TYPES[import_path2.default.extname(argv.file).toLowerCase()];
   if (!fileType) {
     note("Error: unsupported file type. Supported images: JPG, PNG, WEBP, GIF.");
     process.exit(1);
     return;
   }
-  const filename = import_path.default.basename(argv.file);
+  const filename = import_path2.default.basename(argv.file);
   const api = new SuperXAPI(getConfig());
   const created = await api.createMediaUpload({
     filename,
@@ -965,7 +1962,7 @@ async function tagsDelete(argv) {
 }
 
 // src/commands/articles.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 function resolveContent(argv) {
   if (argv.content !== void 0 && argv.file !== void 0) {
     note("Use either --content or --file, not both.");
@@ -974,7 +1971,7 @@ function resolveContent(argv) {
   if (argv.content !== void 0) return argv.content;
   if (argv.file !== void 0) {
     try {
-      return (0, import_fs2.readFileSync)(argv.file, "utf8");
+      return (0, import_fs3.readFileSync)(argv.file, "utf8");
     } catch (err) {
       note(`Could not read ${argv.file}: ${err?.message || err}`);
       process.exit(1);
@@ -982,7 +1979,7 @@ function resolveContent(argv) {
   }
   if (!process.stdin.isTTY) {
     try {
-      const piped = (0, import_fs2.readFileSync)(0, "utf8");
+      const piped = (0, import_fs3.readFileSync)(0, "utf8");
       if (piped.length > 0) return piped;
     } catch {
     }
@@ -1026,7 +2023,7 @@ async function articlesUpdate(argv) {
   if (argv.content !== void 0) body.content_markdown = argv.content;
   if (argv.file !== void 0) {
     try {
-      body.content_markdown = (0, import_fs2.readFileSync)(argv.file, "utf8");
+      body.content_markdown = (0, import_fs3.readFileSync)(argv.file, "utf8");
     } catch (err) {
       note(`Could not read ${argv.file}: ${err?.message || err}`);
       process.exit(1);
@@ -1059,10 +2056,19 @@ async function articlesUnschedule(argv) {
   const api = new SuperXAPI(getConfig());
   printJson(await api.unscheduleArticle(argv.id));
 }
+async function articlesCoverStyles(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.listCoverStyles({ account_id: argv.account }));
+}
 async function articlesCover(argv) {
+  if (argv.style !== void 0 && argv["style-id"] !== void 0) {
+    note("Use either --style or --style-id, not both.");
+    process.exit(1);
+  }
   note("Generating a cover image. This spends AI credits and can take 60-100 seconds...");
   const body = {};
   if (argv.style !== void 0) body.style_text = argv.style;
+  if (argv["style-id"] !== void 0) body.style_id = argv["style-id"];
   if (argv.attach === false) body.attach = false;
   const api = new SuperXAPI(getConfig());
   printJson(await api.generateArticleCover(argv.id, body));
@@ -1073,7 +2079,7 @@ async function contextGet(argv) {
   const api = new SuperXAPI(getConfig());
   printJson(await api.getContext({ account_id: argv.account }));
 }
-function commaList(value) {
+function commaList2(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
 function stringOrClear(value) {
@@ -1092,7 +2098,7 @@ async function contextSet(argv) {
     body.profile_description = profileDescription;
   }
   if (argv.interests !== void 0) {
-    body.interests = commaList(argv.interests);
+    body.interests = commaList2(argv.interests);
   }
   if (argv.rules !== void 0) {
     body.rules = stringOrClear(argv.rules);
@@ -1109,7 +2115,7 @@ async function contextSet(argv) {
   }
   const voice = {};
   if (argv["favorite-creators"] !== void 0) {
-    voice.favorite_creators = commaList(argv["favorite-creators"]);
+    voice.favorite_creators = commaList2(argv["favorite-creators"]);
   }
   if (typeof argv["own-posts-as-examples"] === "boolean") {
     voice.use_own_posts_as_examples = argv["own-posts-as-examples"];
@@ -1145,28 +2151,132 @@ async function contextProductsSet(argv) {
     note("Provide --id (from context:products) to edit, or --url to add or edit by url.");
     process.exit(1);
   }
-  if (argv.id && argv.url) {
-    note("Use either --id or --url, not both.");
+  if (argv.id && argv.url) {
+    note("Use either --id or --url, not both.");
+    process.exit(1);
+  }
+  const body = {};
+  if (argv.name !== void 0) body.name = stringOrClear(argv.name);
+  if (argv.description !== void 0) body.description = stringOrClear(argv.description);
+  if (argv.positioning !== void 0) body.positioning = stringOrClear(argv.positioning);
+  if (argv.features !== void 0) body.features = stringOrClear(argv.features);
+  if (argv.updates !== void 0) body.updates = stringOrClear(argv.updates);
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.updateContextProduct(argv.id || argv.url, body));
+}
+async function contextProductsDelete(argv) {
+  const id = String(argv.id || "").trim();
+  if (!id) {
+    note("Provide the product id. Run: superx context:products:delete --help");
+    process.exit(1);
+  }
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.deleteContextProduct(id, { account_id: argv.account }));
+}
+async function contextProductsReplace(argv) {
+  let products;
+  try {
+    products = JSON.parse(argv.json);
+  } catch (err) {
+    note(`--json is not valid JSON: ${err?.message || err}`);
+    process.exit(1);
+  }
+  if (!Array.isArray(products)) {
+    note(`--json must be a JSON array, e.g. '[{"url":"https://superx.so","name":"SuperX"}]' ('[]' removes every product).`);
+    process.exit(1);
+  }
+  const body = { products };
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.setContextProducts(body));
+}
+async function contextRegenerateStyleGuide(argv) {
+  const body = {};
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.regenerateStyleGuide(body));
+}
+async function contextScrapeProduct(argv) {
+  const id = String(argv.id || "").trim();
+  if (!id) {
+    note("Provide the product id (from context:products). Run: superx context:scrape-product --help");
+    process.exit(1);
+  }
+  const body = {};
+  if (argv.account) body.account_id = argv.account;
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.scrapeContextProduct(id, body));
+}
+
+// src/commands/dm.ts
+var import_fs4 = __toESM(require("fs"));
+function readRecipients(source) {
+  let raw;
+  if (source === "-") {
+    try {
+      raw = import_fs4.default.readFileSync(0, "utf8");
+    } catch (err) {
+      note(`Could not read recipients from stdin: ${err?.message || err}`);
+      process.exit(1);
+    }
+  } else {
+    try {
+      raw = import_fs4.default.readFileSync(source, "utf8");
+    } catch (err) {
+      note(`Could not read ${source}: ${err?.message || err}`);
+      process.exit(1);
+    }
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    note(`--recipients must be JSON: ${err?.message || err}`);
+    process.exit(1);
+  }
+  const list = Array.isArray(parsed) ? parsed : parsed?.recipients;
+  if (!Array.isArray(list) || list.length === 0) {
+    note("--recipients must be a non-empty JSON array of { x_user_id, handle?, name?, message? }.");
     process.exit(1);
   }
-  const body = {};
-  if (argv.name !== void 0) body.name = stringOrClear(argv.name);
-  if (argv.description !== void 0) body.description = stringOrClear(argv.description);
-  if (argv.positioning !== void 0) body.positioning = stringOrClear(argv.positioning);
-  if (argv.features !== void 0) body.features = stringOrClear(argv.features);
-  if (argv.updates !== void 0) body.updates = stringOrClear(argv.updates);
+  return list;
+}
+async function dmCampaign(argv) {
+  const api = new SuperXAPI(getConfig());
+  const recipients = readRecipients(argv.recipients);
+  const body = { recipients };
+  if (argv.message !== void 0) body.message = argv.message;
+  if (argv.spread === true) body.spread = true;
   if (argv.account) body.account_id = argv.account;
+  const { json, replayed } = await api.queueDmCampaign(body, argv["idempotency-key"]);
+  if (replayed) note("Replayed a previous response for this Idempotency-Key. Nothing new was queued.");
+  printJson(json);
+  note("Queued only. The SuperX app sends these within your DM limits; cancel the unsent ones with dm:cancel.");
+}
+async function dmCampaignStatus(argv) {
   const api = new SuperXAPI(getConfig());
-  printJson(await api.updateContextProduct(argv.id || argv.url, body));
+  printJson(await api.getDmCampaign(argv.id, { account_id: argv.account }));
 }
-async function contextProductsDelete(argv) {
-  const id = String(argv.id || "").trim();
-  if (!id) {
-    note("Provide the product id. Run: superx context:products:delete --help");
-    process.exit(1);
-  }
+async function dmCancel(argv) {
   const api = new SuperXAPI(getConfig());
-  printJson(await api.deleteContextProduct(id, { account_id: argv.account }));
+  printJson(await api.cancelDmCampaign(argv.id, { account_id: argv.account }));
+}
+async function dmQueue(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(
+    await api.listDmQueue({
+      limit: argv.limit,
+      offset: argv.offset,
+      status: argv.status,
+      campaign_id: argv.campaign,
+      account_id: argv.account
+    })
+  );
+}
+async function dmLimits(argv) {
+  const api = new SuperXAPI(getConfig());
+  printJson(await api.getDmLimits({ account_id: argv.account }));
 }
 
 // src/commands/queue.ts
@@ -1246,6 +2356,20 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   type: "string"
 }).option("auto-plug-threshold", {
   describe: "Likes threshold for --auto-plug: the reply posts once the post hits this many likes"
+}).option("auto-dm-message", {
+  describe: "Auto DM text (1-1000) sent to people who engage with the post; --no-auto-dm turns it off",
+  type: "string"
+}).option("auto-dm-triggers", {
+  describe: "Who gets the auto DM: comma list of reply,repost (retweet = repost). Default reply",
+  type: "string"
+}).option("auto-dm-max", {
+  describe: "Most people to auto DM for this post (1-100, default 100)"
+}).option("auto-dm-batch", {
+  describe: "Send the auto DMs in one batch instead of as engagement arrives",
+  type: "boolean"
+}).option("auto-dm", {
+  describe: "Only the negated form is used: --no-auto-dm turns Auto DM off for this post",
+  type: "boolean"
 }).option("super-followers", {
   describe: "Post to Super Followers only (--no-super-followers turns it off)",
   type: "boolean"
@@ -1281,6 +2405,116 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   "Account analytics: totals, daily series, follower change (default: last 30 days)",
   (y) => accountOption(y).option("since", { describe: "Start of range (UTC ISO-8601)", type: "string" }).option("until", { describe: "End of range (UTC ISO-8601)", type: "string" }).example('$0 posts:analytics --since "2026-06-01T00:00:00Z" --until "2026-07-01T00:00:00Z"', "June analytics"),
   run(postsAnalytics)
+).command(
+  "posts:draft",
+  "Write post drafts in your voice from a brief (nothing is scheduled; costs AI credits)",
+  (y) => accountOption(y).option("brief", {
+    describe: "What the post should say: the data, angle, or notes to write from (required, max 2000 chars)",
+    type: "string"
+  }).option("count", {
+    describe: "How many drafts to write, 1 to 3 (default 1). Each one costs credits",
+    type: "number"
+  }).option("voice", {
+    describe: "Whose voice to write in; mine is the voice of the account passed in --account, or your main account if --account is omitted",
+    type: "string",
+    choices: ["mine", "creator", "hybrid"]
+  }).option("creator", {
+    describe: "X handle to borrow style from (needed for --voice creator or hybrid)",
+    type: "string"
+  }).option("mirror", {
+    describe: "Text of a proven post whose SHAPE to copy (50-1500 chars); pick one with room for your data, a two-line aphorism squeezes the facts out; omit to have one picked",
+    type: "string"
+  }).option("collection", {
+    describe: "Format collection id to bias the picked shape toward; used only without --mirror",
+    type: "string"
+  }).option("instructions", {
+    describe: "Extra style instructions for this batch (max 500 chars)",
+    type: "string"
+  }).example('$0 posts:draft --brief "We cut churn from 6.2% to 3.8% by replacing the onboarding video with a checklist"', "One draft in your voice").example('$0 posts:draft --brief "..." --count 3 --mirror "$(cat proven-post.txt)"', "Three drafts copying a proven post shape").example('$0 posts:draft --brief "..." --voice hybrid --creator @naval', "Your substance, a creator's flavor"),
+  run(postsDraft)
+).command(
+  "posts:remix",
+  "Rewrite a post in your voice, near or far from the original (nothing is posted; costs AI credits)",
+  (y) => accountOption(y).option("text", {
+    describe: "The post to remix (required, max 4000 chars)",
+    type: "string",
+    demandOption: true
+  }).option("closeness", {
+    describe: "0 keeps only the idea, 100 stays very close to the original wording (required)",
+    type: "number",
+    demandOption: true
+  }).option("instructions", {
+    describe: "Extra direction for this remix (max 500 chars)",
+    type: "string"
+  }).example('$0 posts:remix --text "$(cat post.txt)" --closeness 70', "A close rewrite in your voice").example('$0 posts:remix --text "..." --closeness 20 --instructions "make it a question"', "A loose reinterpretation").epilogue(
+    "Returns TEXT ONLY. Nothing is posted or scheduled: save the result with posts:draft or scheduled:create once you are happy with it."
+  ),
+  run(postsRemix)
+).command(
+  "tools:inline-edit",
+  "Edit one selected piece of a post, keeping the surrounding style (costs AI credits)",
+  (y) => accountOption(y).option("text", {
+    describe: "The selected piece to edit (required, max 4000 chars)",
+    type: "string",
+    demandOption: true
+  }).option("full", {
+    describe: "The whole post the selection sits in, so the edit matches its style",
+    type: "string"
+  }).option("instruction", { describe: "Free-text direction, e.g. 'make this one line'", type: "string" }).option("type", {
+    describe: "A preset edit instead of, or alongside, --instruction",
+    type: "string",
+    choices: [
+      "grammar",
+      "translate",
+      "hook",
+      "details",
+      "concise",
+      "engaging",
+      "humorous",
+      "creative",
+      "sarcastic",
+      "inspirational"
+    ]
+  }).example('$0 tools:inline-edit --text "the hook line" --full "$(cat post.txt)" --type hook', "Sharpen the hook in place").epilogue("Provide --instruction, --type, or both. Returns TEXT ONLY; nothing is posted."),
+  run(toolsInlineEdit)
+).command(
+  "tools:rephrase",
+  "Rewrite a post one preset way (costs AI credits)",
+  (y) => accountOption(y).option("type", {
+    describe: "Which rewrite to apply. The style presets use your voice; the mechanical ones do not",
+    type: "string",
+    demandOption: true,
+    choices: [
+      "improve",
+      "grammar",
+      "translate",
+      "hook",
+      "details",
+      "clarity",
+      "engaging",
+      "humorous",
+      "positive",
+      "creative",
+      "sarcastic",
+      "inspirational",
+      "concise"
+    ]
+  }).option("text", { describe: "The post to rewrite (required)", type: "string", demandOption: true }).example('$0 tools:rephrase --type concise --text "$(cat post.txt)"', "Tighten a post").epilogue("Returns TEXT ONLY; nothing is posted."),
+  run(toolsRephrase)
+).command(
+  "tools:factcheck",
+  "Check a statement against a web search and report true, false or unknown (costs AI credits)",
+  (y) => accountOption(y).option("text", { describe: "The statement to check (required)", type: "string", demandOption: true }).example('$0 tools:factcheck --text "X has 600M daily active users"', "Check a claim before posting it").epilogue(
+    "The verdict is a model's reading of a couple of search results, not a guarantee. Read the sources it returns before acting on it."
+  ),
+  run(toolsFactcheck)
+).command(
+  "tools:predict",
+  "Score two versions of a post against what the timeline rewards (costs AI credits)",
+  (y) => accountOption(y).option("a", { describe: "The first version (required)", type: "string", demandOption: true }).option("b", { describe: "The second version (required)", type: "string", demandOption: true }).example('$0 tools:predict --a "$(cat v1.txt)" --b "$(cat v2.txt)"', "Compare two drafts").epilogue(
+    "The scores are a model's opinion, useful for comparing two drafts against each other, not a prediction of real reach."
+  ),
+  run(toolsPredict)
 ).command(
   "replies:list",
   "List replies the account has sent (newest first)",
@@ -1304,6 +2538,31 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
     choices: ["relevant", "recent", "likes", "reposts", "impressions", "outlier"]
   }).option("min-likes", { describe: "Only posts with at least this many likes", type: "number" }).option("min-reposts", { describe: "Only posts with at least this many reposts", type: "number" }).option("min-replies", { describe: "Only posts with at least this many replies", type: "number" }).option("min-bookmarks", { describe: "Only posts with at least this many bookmarks", type: "number" }).option("min-impressions", { describe: "Only posts with at least this many impressions", type: "number" }).option("min-followers", { describe: "Only posts from authors with at least this many followers", type: "number" }).option("max-followers", { describe: "Only posts from authors with at most this many followers", type: "number" }).option("since", { describe: "Only posts after this time (UTC ISO-8601)", type: "string" }).option("until", { describe: "Only posts before this time (UTC ISO-8601)", type: "string" }).option("lang", { describe: "Language code (default en)", type: "string" }).option("exclude-topics", { describe: "Comma-separated topics to exclude", type: "string" }).example('$0 inspiration:search "build in public" --limit 10', "Ten posts about building in public").example('$0 inspiration:search "indie hackers" --sort outlier --min-likes 500', "Overperformers with 500+ likes"),
   run(inspirationSearch)
+).command(
+  "inspiration:media [query]",
+  "Search the cross-platform media index behind the app's Inspiration > Media tab",
+  (y) => y.positional("query", {
+    describe: "What to search for. Omit to browse the newest media",
+    type: "string"
+  }).option("platforms", {
+    describe: "Comma-separated platforms: x, instagram, youtube, threads, reddit, linkedin",
+    type: "string"
+  }).option("time-filter", {
+    describe: "How recent the media must be",
+    type: "string",
+    choices: ["all", "24h", "7d", "30d"]
+  }).option("media-type", {
+    describe: "Media kind",
+    type: "string",
+    choices: ["all", "video", "image"]
+  }).option("content-type", {
+    describe: "Free-text content-type label as stored in the index; an unknown label returns nothing and still costs a search",
+    type: "string"
+  }).option("limit", {
+    describe: "Items to return (1-120, default 20). No pagination: 120 is one query's maximum",
+    type: "number"
+  }).example('$0 inspiration:media "founder morning routine" --limit 10', "Ten media posts on that theme").example("$0 inspiration:media --platforms youtube,instagram", "Browse the newest video-platform media"),
+  run(inspirationMedia)
 ).command(
   "contacts:list",
   "List the people who engage with you most",
@@ -1322,6 +2581,34 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
     choices: ["recent", "most_liked"]
   }),
   run(contactsReplies)
+).command(
+  "contacts:get <id>",
+  "Show one person: profile, follower counts and the lists they are in (your known contacts only: engagers, contact-list members, signal leads)",
+  (y) => accountOption(y).positional("id", { describe: "Numeric X user id (from contacts:list, lists:members or signals:leads)", type: "string" }).option("refresh", {
+    describe: "Refresh the profile from X when the stored copy is stale (counts against the enrichment limit)",
+    type: "boolean"
+  }),
+  run(contactsGet)
+).command(
+  "contacts:notes <id>",
+  "List your private notes about one person (newest first)",
+  (y) => accountOption(y).positional("id", { describe: "Numeric X user id", type: "string" }),
+  run(contactsNotes)
+).command(
+  "contacts:notes:add <id>",
+  "Write a private note about one person (never posted anywhere; known contacts only: engagers, contact-list members, signal leads)",
+  (y) => accountOption(y).positional("id", { describe: "Numeric X user id", type: "string" }).option("body", { describe: "Note text (1-5000 chars)", type: "string", demandOption: true }).example('$0 contacts:notes:add 44196397 --body "Met at the SaaS meetup, wants a demo"', "Add a note"),
+  run(contactsNotesAdd)
+).command(
+  "contacts:notes:update <id> <noteId>",
+  "Rewrite one note (the new body fully replaces the old one)",
+  (y) => accountOption(y).positional("id", { describe: "Numeric X user id", type: "string" }).positional("noteId", { describe: "Note id (from contacts:notes)", type: "string" }).option("body", { describe: "Replacement note text (1-5000 chars)", type: "string", demandOption: true }),
+  run(contactsNotesUpdate)
+).command(
+  "contacts:notes:delete <id> <noteId>",
+  "Delete one note (note id from contacts:notes)",
+  (y) => accountOption(y).positional("id", { describe: "Numeric X user id", type: "string" }).positional("noteId", { describe: "Note id (from contacts:notes)", type: "string" }),
+  run(contactsNotesDelete)
 ).command(
   "lists:list",
   "List your contact lists (system lists are read-only)",
@@ -1342,11 +2629,229 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   "Remove a member from a contact list (member id from lists:members)",
   (y) => y.positional("id", { describe: "List id (from lists:list)", type: "string" }).positional("memberId", { describe: "Member id (from lists:members)", type: "string" }),
   run(listsRemoveMember)
+).command(
+  "lists:create",
+  "Create a contact list (names are not unique)",
+  (y) => accountOption(y).option("name", { describe: "List name (1-120 chars)", type: "string", demandOption: true }).example('$0 lists:create --name "Founder prospects"', "Create a list"),
+  run(listsCreate)
+).command(
+  "lists:rename <id>",
+  "Rename a contact list you created (system lists are read-only)",
+  (y) => accountOption(y).positional("id", { describe: "List id (from lists:list)", type: "string" }).option("name", { describe: "New name (1-120 chars)", type: "string", demandOption: true }),
+  run(listsRename)
+).command(
+  "lists:delete <id>",
+  "Delete a contact list you created and its membership (the people stay)",
+  (y) => accountOption(y).positional("id", { describe: "List id (from lists:list)", type: "string" }),
+  run(listsDelete)
+).command(
+  "lists:add-members <id>",
+  "Add up to 500 people at once by X user id (ids SuperX already knows)",
+  (y) => accountOption(y).positional("id", { describe: "List id (from lists:list)", type: "string" }).option("x-user-ids", {
+    describe: "Comma list of numeric X user ids (max 500); ids SuperX has never seen come back in not_found",
+    type: "string",
+    demandOption: true
+  }).example("$0 lists:add-members abc123 --x-user-ids 44196397,1234567890", "Add two people by id"),
+  run(listsAddMembers)
+).command(
+  "lists:remove-members <id>",
+  "Remove up to 500 members at once by member id (from lists:members)",
+  (y) => accountOption(y).positional("id", { describe: "List id (from lists:list)", type: "string" }).option("member-ids", {
+    describe: "Comma list of member ids (max 500, from lists:members)",
+    type: "string",
+    demandOption: true
+  }),
+  run(listsRemoveMembers)
+).command(
+  "datasets:list",
+  "List the audience collections Ask SuperX built in the app (kept for 30 days)",
+  (y) => paginationOptions(y),
+  run(datasetsList)
+).command(
+  "datasets:get <id>",
+  "Read one dataset: status, counts, coverage (poll this while it collects)",
+  (y) => y.positional("id", { describe: "Dataset id (from datasets:list)", type: "string" }),
+  run(datasetsGet)
+).command(
+  "datasets:rows <id>",
+  "Read a page of a ready dataset's rows, exactly as collected",
+  (y) => paginationOptions(y).positional("id", {
+    describe: "Dataset id (from datasets:list)",
+    type: "string"
+  }),
+  run(datasetsRows)
+).command(
+  "datasets:export <id>",
+  "Download a ready dataset as CSV (XLSX stays in the SuperX app)",
+  (y) => y.positional("id", { describe: "Dataset id (from datasets:list)", type: "string" }).option("out", {
+    describe: "File to write; defaults to the server's filename in the current directory. Use - to stream the CSV to stdout",
+    type: "string",
+    // Without requiresArg, yargs drops a lone `-` and strict mode
+    // rejects it as an unknown argument, so `--out -` would fail.
+    requiresArg: true
+  }).example("$0 datasets:export abc123", "Write superx-dataset-<title>-<date>.csv here").example("$0 datasets:export abc123 --out - | head", "Stream the CSV to stdout"),
+  run(datasetsExport)
+).command(
+  "datasets:add-to-list <id>",
+  "Copy the people in a ready dataset into a contact list you created",
+  (y) => accountOption(y).positional("id", { describe: "Dataset id (from datasets:list)", type: "string" }).option("list-id", {
+    describe: "Contact list id (from lists:list) that receives the people",
+    type: "string",
+    demandOption: true
+  }).example("$0 datasets:add-to-list abc123 --list-id def456", "Add the dataset's people to a list"),
+  run(datasetsAddToList)
+).command(
+  "datasets:collect",
+  "Collect an audience (or your own posts) into a new dataset",
+  (y) => accountOption(y).option("source", {
+    describe: "Who to collect",
+    type: "string",
+    choices: [
+      "repliers",
+      "quoters",
+      "reposters",
+      "list_members",
+      "my_replies",
+      "my_posts"
+    ],
+    demandOption: true
+  }).option("target", {
+    describe: "Post URL or id (repliers, quoters, reposters), or X list URL or id (list_members). Not used for my_posts / my_replies",
+    type: "string"
+  }).option("title", { describe: "Title for the dataset", type: "string" }).option("max-rows", { describe: "Rows to collect at most (1-1000, default 500)", type: "number" }).option("keywords", {
+    describe: "Comma list: keep only rows whose reply, quote or post text contains one of these",
+    type: "string"
+  }).option("bio-keywords", {
+    describe: "Comma list: keep only people whose X bio contains one of these",
+    type: "string"
+  }).option("min-followers", { describe: "Keep only people with at least this many followers", type: "number" }).option("require-website", { describe: "Keep only people with a website in their profile", type: "boolean" }).option("require-can-dm", { describe: "Keep only people whose DMs look open", type: "boolean" }).option("since-days", { describe: "Own posts only: keep posts from the last N days", type: "number" }).option("sort", {
+    describe: "Own posts only: which posts to keep when max-rows cuts the list",
+    type: "string",
+    choices: ["recent", "likes", "impressions"]
+  }).option("wait", {
+    describe: "Poll until a background collection is ready (up to 15 minutes)",
+    type: "boolean"
+  }).example(
+    "$0 datasets:collect --source repliers --target https://x.com/me/status/123 --wait",
+    "Collect everyone who replied and wait for it"
+  ).epilogue(
+    "Costs one of 10 collections a day, shared with the collections Ask SuperX runs in the app. A big collection answers with status collecting and keeps running in the background: poll it with datasets:get, or pass --wait."
+  ),
+  run(datasetsCollect)
+).command(
+  "datasets:research",
+  "Research people into outreach briefs saved as a dataset",
+  (y) => accountOption(y).option("handles", {
+    describe: "Comma list of X handles to research (with or without the @). Max 25",
+    type: "string"
+  }).option("list", { describe: "Research the members of this contact list id", type: "string" }).option("agent", { describe: "Research this signal agent's leads (numeric id)", type: "number" }).option("dataset", { describe: "Research the people in this dataset id", type: "string" }).option("max", { describe: "Profiles to research, first N from the source (1-25, default 10)", type: "number" }).option("focus", {
+    describe: "Optional steer, e.g. 'founders who might need audience-growth tooling'",
+    type: "string"
+  }).option("title", { describe: "Title for the briefs dataset", type: "string" }).option("wait", {
+    describe: "Poll until a background research run is ready (up to 15 minutes)",
+    type: "boolean"
+  }).example(
+    "$0 datasets:research --handles levelsio,naval --focus 'audience-growth tooling'",
+    "Research two handles into briefs"
+  ).epilogue(
+    "Give exactly one source: --handles, --list, --agent or --dataset. Costs 1 AI credit per profile actually researched (the rest are returned) plus one of the plan's daily research runs. More than 5 profiles run in the background: the result says status collecting, so poll with datasets:get or pass --wait. Live-data actions also draw on a platform-wide fair-use ceiling shared by every account."
+  ),
+  run(datasetsResearch)
+).command(
+  "datasets:outreach-drafts <id>",
+  "Draft one personalized message per person in a research dataset (text only, nothing is sent)",
+  (y) => accountOption(y).positional("id", { describe: "Research dataset id (from datasets:research)", type: "string" }).option("format", {
+    describe: "The template or example message every draft should follow (10-1000 chars)",
+    type: "string",
+    demandOption: true
+  }).option("instructions", {
+    describe: "Optional extra steer: tone, what to emphasize, what to avoid",
+    type: "string"
+  }).example(
+    '$0 datasets:outreach-drafts abc123 --format "hey [first]! <personalization>. would love to trade notes"',
+    "Draft messages onto the dataset"
+  ).epilogue(
+    "The drafts are TEXT: they are stored on the dataset (read them with datasets:rows) and a person sends them from the SuperX app. Nothing here sends a DM. Re-running overwrites every draft. [name], [first] and [handle] tokens are kept for per-recipient fill-in at send time."
+  ),
+  run(datasetsOutreachDrafts)
+).command(
+  "datasets:refine <id>",
+  "Filter a dataset by what each person wrote, into a new dataset",
+  (y) => accountOption(y).positional("id", { describe: "Source dataset id (from datasets:list)", type: "string" }).option("criterion", {
+    describe: "What the rows to match look like, judged on each row's own text",
+    type: "string",
+    demandOption: true
+  }).option("keep", {
+    describe: "Keep the rows that MATCH (default). --no-keep keeps the rows that do not",
+    type: "boolean"
+  }).option("sort", {
+    describe: "Sort the kept rows descending before the limit",
+    type: "string",
+    choices: ["followers", "likes", "none"]
+  }).option("limit", { describe: "Keep at most this many rows after filtering and sorting", type: "number" }).option("title", { describe: "Title for the new dataset", type: "string" }).option("wait", {
+    describe: "Poll until a background refinement is ready (up to 15 minutes)",
+    type: "boolean"
+  }).example(
+    "$0 datasets:refine abc123 --criterion 'supportive or neutral, not hostile' --sort followers",
+    "Keep the friendly repliers, best-followed first"
+  ).epilogue(
+    "The source dataset is untouched. Only datasets whose rows carry text (repliers, quoters) can be refined this way. Rows the classifier cannot judge are KEPT and counted as unclear. A refinement creates a dataset, so it counts against the same 10 collections a day, and it costs AI credits."
+  ),
+  run(datasetsRefine)
+).command(
+  "x:post <id|url>",
+  "Look up one public X post live (URL or numeric id)",
+  (y) => y.positional("id", { describe: "Post URL or bare numeric post id", type: "string" }).option("quotes", {
+    describe: "Also fetch a page of the posts quoting it (costs a second unit)",
+    type: "boolean"
+  }).example("$0 x:post https://x.com/levelsio/status/1938765432109876543", "Read that post"),
+  run(xPost)
+).command(
+  "x:replies <id|url>",
+  "Top replies by likes to a public X post, live (a sample, not every reply)",
+  (y) => y.positional("id", { describe: "Post URL or bare numeric post id", type: "string" }).option("limit", { describe: "Replies to return (1-20, default 10)", type: "number" }).example("$0 x:replies 1938765432109876543 --limit 20", "The twenty best-liked replies"),
+  run(xReplies)
+).command(
+  "x:user <handle>",
+  "Look up one public X profile live (@ optional)",
+  (y) => y.positional("handle", { describe: "The account's @handle", type: "string" }).example("$0 x:user @levelsio", "Read that profile"),
+  run(xUser)
+).command(
+  "x:user-posts <handle>",
+  "One live page of an account's latest posts, newest first",
+  (y) => y.positional("handle", { describe: "The account's @handle", type: "string" }).option("limit", { describe: "Posts to return (1-20, default 10)", type: "number" }).option("reposts", {
+    describe: "Include reposts (default). Use --no-reposts for own posts only",
+    type: "boolean",
+    default: true
+  }).example("$0 x:user-posts levelsio --no-reposts", "Their own recent posts, no reposts"),
+  run(xUserPosts)
 ).command(
   "signals:agents",
   "List your signal agents (automated lead finders) with their watched signals",
   (y) => accountOption(y),
   run(signalsAgents)
+).command(
+  "signals:search",
+  "Search X now for people matching an audience description (saves nothing)",
+  (y) => accountOption(y).option("keywords", {
+    describe: "Plain-language phrases these people would post, comma-separated for alternatives. No search operators",
+    type: "string",
+    demandOption: true
+  }).option("icp", {
+    describe: "Who counts as a good lead, in 1-2 sentences: role, domain, and the intent that qualifies them",
+    type: "string",
+    demandOption: true
+  }).option("precision", {
+    describe: "high = only confident matches; discovery (default) = broader adjacent matches",
+    type: "string",
+    choices: ["high", "discovery"]
+  }).option("max", { describe: "Leads to return at most (1-30, default 10)", type: "number" }).example(
+    "$0 signals:search --keywords 'losing customers to churn' --icp 'B2B SaaS founders worried about retention'",
+    "Find people posting about churn right now"
+  ).epilogue(
+    "This CREATES NOTHING: no signal agent, no saved leads. Use signals:create-agent for an audience that keeps filling up. Reading X live costs AI credits (at least 1) plus one of the plan's daily lead searches, and draws on a platform-wide fair-use ceiling shared by every account. Takes up to a minute."
+  ),
+  run(signalsSearch)
 ).command(
   "signals:leads",
   "List the leads your signal agents have found (newest first)",
@@ -1373,6 +2878,10 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
     describe: "Plain-language search description to watch (repeat the flag, 1-5); omit to auto-suggest from --icp",
     type: "string",
     array: true
+  }).option("signal", {
+    describe: 'Non-keyword signal as "type:target" (repeat the flag). Types: keyword, profile, follower, list. Combined with --keyword, at most 5',
+    type: "string",
+    array: true
   }).option("idempotency-key", {
     describe: "Idempotency-Key header (max 64 chars); retries with the same key return the original result",
     type: "string"
@@ -1382,8 +2891,77 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   ).example(
     '$0 signals:create-agent --name "Agency leads" --icp "Marketing agency owners struggling with reporting"',
     "Create an agent with auto-suggested keywords and an auto-created list"
+  ).example(
+    '$0 signals:create-agent --name "Naval orbit" --icp "..." --signal "profile:@naval" --signal "follower:@naval"',
+    "Create an agent watching an account and its followers"
   ),
   run(signalsCreateAgent)
+).command(
+  "signals:update-agent <id>",
+  "Edit a signal agent's name, ICP, precision mode, destination list or status",
+  (y) => y.positional("id", { describe: "Agent id (from signals:agents)", type: "number" }).option("name", { describe: "New agent name (max 80 chars)", type: "string" }).option("icp", { describe: "New ideal-customer description (max 500 chars)", type: "string" }).option("precision", {
+    describe: "high = fewer, stricter matches; discovery = broader net",
+    type: "string",
+    choices: ["high", "discovery"]
+  }).option("list-id", {
+    describe: "Contact list id (from lists:list) that receives the leads",
+    type: "string"
+  }).option("status", {
+    describe: "active = resume finding leads; paused = stop",
+    type: "string",
+    choices: ["active", "paused"]
+  }).example('$0 signals:update-agent 3 --icp "Series A founders hiring their first RevOps lead"', "Retune the scoring").example("$0 signals:update-agent 3 --list-id abc123", "Send new leads to a different list"),
+  run(signalsUpdateAgent)
+).command(
+  "signals:add-signal <id>",
+  "Add one thing for an agent to watch (a search, an account, its followers, or an X list)",
+  (y) => accountOption(y).positional("id", { describe: "Agent id (from signals:agents)", type: "number" }).option("type", {
+    describe: "What to watch",
+    type: "string",
+    choices: ["keyword_watch", "profile_watch", "follower_watch", "list_watch"],
+    demandOption: true
+  }).option("query", { describe: "For keyword_watch: the search description (max 180 chars)", type: "string" }).option("handle", { describe: "For profile_watch / follower_watch: an X username", type: "string" }).option("list", { describe: "For list_watch: a public X list id or x.com/i/lists link", type: "string" }).example('$0 signals:add-signal 3 --type keyword_watch --query "just raised a seed round"', "Watch a search").example("$0 signals:add-signal 3 --type follower_watch --handle naval", "Watch who an account follows"),
+  run(signalsAddSignal)
+).command(
+  "signals:remove-signal <id> <signalId>",
+  "Remove one signal from an agent (leads it already found stay)",
+  (y) => y.positional("id", { describe: "Agent id (from signals:agents)", type: "number" }).positional("signalId", { describe: "Signal id (from the agent's signals in signals:agents)", type: "number" }),
+  run(signalsRemoveSignal)
+).command(
+  "signals:feedback <leadId>",
+  "Record your verdict on one lead: --fit, --not-fit or --clear",
+  (y) => accountOption(y).positional("leadId", { describe: "Numeric lead id (from signals:leads)", type: "number" }).option("fit", { describe: "Mark the lead a good match", type: "boolean" }).option("not-fit", { describe: "Mark the lead a bad match", type: "boolean" }).option("clear", { describe: "Remove any verdict on the lead", type: "boolean" }).example("$0 signals:feedback 4821 --fit", "Teach the scorer this lead was right").epilogue("The verdict trains the scorer, so record it on leads you actually reviewed."),
+  run(signalsFeedback)
+).command(
+  "signals:suggest-keywords",
+  "Turn an audience description into 2 or 3 keyword-watch ideas (free, creates nothing)",
+  (y) => accountOption(y).option("icp", {
+    describe: "Who the ideal customer is, in plain language (3 to 500 chars)",
+    type: "string",
+    demandOption: true
+  }).example(
+    `$0 signals:suggest-keywords --icp "B2B SaaS founders worried about churn"`,
+    "Ideas to watch for that audience"
+  ).epilogue(
+    "Saves nothing and costs no AI credits. Pass a suggestion you like to signals:create-agent --keyword, or signals:add-signal --type keyword_watch."
+  ),
+  run(signalsSuggestKeywords)
+).command(
+  "signals:expand-icp",
+  "Build the scoring rubric a signal agent qualifies people with, from a description or a website (free)",
+  (y) => accountOption(y).option("text", {
+    describe: "Who the ideal customer is, in plain language (3 to 500 chars)",
+    type: "string"
+  }).option("url", {
+    describe: "A product or company website to read instead; also returns a description and keyword ideas",
+    type: "string"
+  }).example(
+    `$0 signals:expand-icp --text "Indie founders building SaaS in public"`,
+    "Rubric from a description"
+  ).example("$0 signals:expand-icp --url superx.so", "Rubric, description and keyword ideas from a site").epilogue(
+    "Provide --text or --url, not both. Saves nothing and costs no AI credits; --url reads a page on the account's allowance of 20 page reads a day, shared with the SuperX app, and takes up to a minute. The rubric is a reading of the description, not a field you can store: agents are created with --icp, so use it to sharpen that text first. With --url, the icp_description it returns is what you pass to signals:create-agent --icp."
+  ),
+  run(signalsExpandIcp)
 ).command(
   "signals:pause-agent <id>",
   "Pause a signal agent (it stops finding leads until resumed)",
@@ -1399,6 +2977,49 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   "Delete a signal agent (its saved leads and contact list stay untouched)",
   (y) => y.positional("id", { describe: "Agent id (from signals:agents)", type: "number" }),
   run(signalsDeleteAgent)
+).command(
+  "workers:list",
+  "List your Workers (the agents that write posts for you on a schedule)",
+  (y) => accountOption(y).example("$0 workers:list", "Your Workers, their schedules and next run times").epilogue(
+    "Workers are created, edited and run in the SuperX app. This reads them so you can tell which Worker a suggestion came from."
+  ),
+  run(workersList)
+).command(
+  "workers:suggestions",
+  "List the posts your Workers have written, newest first",
+  (y) => paginationOptions(accountOption(y)).option("status", {
+    describe: "to_review (default) = waiting on you; drafted / scheduled = already saved; dismissed = cleared; all = everything",
+    type: "string",
+    choices: ["to_review", "drafted", "scheduled", "dismissed", "all"]
+  }).option("worker", { describe: "Narrow to one Worker by its numeric id (from workers:list)", type: "number" }).example("$0 workers:suggestions --limit 10", "Ten newest posts waiting for review").example("$0 workers:suggestions --worker 3 --status all", "Everything Worker 3 has written").epilogue(
+    "Reading suggestions costs nothing and changes nothing. Act on one with workers:draft, workers:schedule or workers:dismiss."
+  ),
+  run(workersSuggestions)
+).command(
+  "workers:draft <id>",
+  "Save one Worker suggestion as a draft (nothing is posted)",
+  (y) => accountOption(y).positional("id", { describe: "Suggestion id (from workers:suggestions)", type: "number" }).example("$0 workers:draft 4821", "Move it into Drafts, where scheduled:list --status draft finds it").epilogue(
+    "The draft keeps the Worker's text as written. Edit it with scheduled:update, or rewrite it first with posts:remix and then save your own version."
+  ),
+  run(workersDraft)
+).command(
+  "workers:schedule <id>",
+  "Schedule one Worker suggestion to post at a given time",
+  (y) => accountOption(y).positional("id", { describe: "Suggestion id (from workers:suggestions)", type: "number" }).option("at", {
+    describe: "When to post, UTC ISO-8601 (for example 2026-09-15T14:00:00Z)",
+    type: "string",
+    demandOption: true
+  }).example("$0 workers:schedule 4821 --at 2026-09-15T14:00:00Z", "Queue it for Tuesday afternoon").epilogue(
+    "The post does not inherit your Default Post Settings: it carries only what this call passes, which is nothing beyond the time. Add auto retweet, auto plug or auto delete afterwards with scheduled:update, which also retimes it; scheduled:delete cancels it."
+  ),
+  run(workersSchedule)
+).command(
+  "workers:dismiss <id>",
+  "Clear one Worker suggestion out of the To review list",
+  (y) => accountOption(y).positional("id", { describe: "Suggestion id (from workers:suggestions)", type: "number" }).example("$0 workers:dismiss 4821", "Skip this one").epilogue(
+    "Dismissing drops it from the default to_review list. It stays readable with --status dismissed, and nothing already drafted or scheduled is affected."
+  ),
+  run(workersDismiss)
 ).command(
   "engage:feeds",
   "List the Engage feeds set up in the app",
@@ -1425,6 +3046,82 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
     type: "string"
   }).example("$0 engage:posts <feed-id> --limit 50", "One big page from a keyword feed").example("$0 engage:posts <feed-id> --mode latest --fresh true", "Newest posts, skipping the cache").example("$0 engage:posts <feed-id> --exclude 1234567890,1234567891", "Next batch, minus the posts you have"),
   run(engagePosts)
+).command(
+  "engage:feeds:create",
+  "Save a new Engage feed (keywords, a public X list, or one of your contact lists)",
+  (y) => accountOption(y).option("name", { describe: "Feed name (1-40 chars)", type: "string", demandOption: true }).option("keyword", {
+    describe: "Search term for a keyword feed (repeat the flag, 1-5)",
+    type: "string",
+    array: true
+  }).option("x-list", {
+    describe: "Public X list id or x.com/i/lists link for an X list feed",
+    type: "string"
+  }).option("list-id", { describe: "Contact list id (from lists:list) for a list feed", type: "string" }).example('$0 engage:feeds:create --name "AI builders" --keyword "shipping with LLMs" --keyword "eval harness"', "A keyword feed").example('$0 engage:feeds:create --name "Founders" --x-list https://x.com/i/lists/1234567890', "A public X list feed").epilogue(
+    "Use exactly one source. A new feed does not become the feed the SuperX app has open. Up to 8 feeds per account."
+  ),
+  run(engageFeedsCreate)
+).command(
+  "engage:feeds:update <feedId>",
+  "Rename an Engage feed, replace what it watches, or both",
+  (y) => accountOption(y).positional("feedId", { describe: "Feed id (from engage:feeds)", type: "string" }).option("name", { describe: "New feed name (1-40 chars)", type: "string" }).option("keyword", {
+    describe: "Replace the feed's keywords (repeat the flag, 1-5)",
+    type: "string",
+    array: true
+  }).option("x-list", { describe: "Point the feed at this X list id or link", type: "string" }).option("list-id", { describe: "Point the feed at this contact list (from lists:list)", type: "string" }).example('$0 engage:feeds:update <feed-id> --name "AI builders"', "Rename a feed").epilogue("Change one source at a time; a feed may change type and keeps its id."),
+  run(engageFeedsUpdate)
+).command(
+  "engage:feeds:delete <feedId>",
+  "Delete an Engage feed (if it was the open one, the first remaining feed takes over)",
+  (y) => accountOption(y).positional("feedId", { describe: "Feed id (from engage:feeds)", type: "string" }),
+  run(engageFeedsDelete)
+).command(
+  "engage:reply-draft",
+  "Draft one reply to a post, in your voice (nothing is posted; costs AI credits)",
+  (y) => accountOption(y).option("post", {
+    describe: "X post id to reply to; the API reads it live (costs one live lookup). Use instead of --text",
+    type: "string"
+  }).option("text", { describe: "The post's text, supplied by you. Use instead of --post", type: "string" }).option("author", { describe: "The author's display name, with --text", type: "string" }).option("handle", { describe: "The author's @handle without the @, with --text", type: "string" }).option("thoughts", {
+    describe: "What you want the reply to convey (max 2000 chars)",
+    type: "string"
+  }).option("tone", {
+    describe: "Register for the reply",
+    type: "string",
+    choices: ["engaging", "humorous", "creative", "sarcastic", "inspirational", "concise"]
+  }).example('$0 engage:reply-draft --post 1234567890 --thoughts "agree, and add that we saw the same thing"', "Draft a reply to a real post").example('$0 engage:reply-draft --text "hot take about pricing" --handle levelsio --tone concise', "Draft from text you paste in").epilogue(
+    "Provide exactly one of --post or --text. The draft is TEXT: nothing is posted or sent, a person reviews it and posts it."
+  ),
+  run(engageReplyDraft)
+).command(
+  "engage:mentions",
+  "The posts @-mentioning you right now, each with the post it replies to",
+  (y) => accountOption(y).option("sort", {
+    describe: "latest (default, newest first) or top (most engaged first)",
+    type: "string",
+    choices: ["latest", "top"]
+  }).option("include-replied", {
+    describe: "Keep mentions you already replied to on X, flagged replied",
+    type: "boolean"
+  }).option("cursor", {
+    describe: "next_cursor from the previous call, to read the next page",
+    type: "string"
+  }).example("$0 engage:mentions --sort top", "The most engaged mentions first").epilogue(
+    "Reads X live and costs 3 of your daily feed fetches per call, so read a page and work from it rather than polling. Page with --cursor."
+  ),
+  run(engageMentions)
+).command(
+  "audience:list <kind>",
+  "A page of your followers, following, repliers or reposters",
+  (y) => accountOption(y).positional("kind", {
+    describe: "followers, following, repliers or reposters",
+    type: "string",
+    choices: ["followers", "following", "repliers", "reposters"]
+  }).option("cursor", {
+    describe: "next_cursor from the previous call, to read the next page",
+    type: "string"
+  }).option("limit", { describe: "People per page (1-100, default 50)", type: "number" }).example("$0 audience:list followers --limit 100", "The first 100 followers").epilogue(
+    "These are the four system lists in the app's Contacts tab; lists:members does not serve them. Paging is by cursor, not page number, and meta.synced_count is the size of the whole list. Repliers and reposters cover a rolling 90 days."
+  ),
+  run(audienceList)
 ).command(
   "scheduled:list",
   "List drafts and the scheduled queue",
@@ -1503,6 +3200,49 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   "Delete a draft or scheduled post by id",
   (y) => y.positional("id", { describe: "Post id (from scheduled:list or scheduled:create)", type: "string" }),
   run(scheduledDelete)
+).command(
+  "posts:publish",
+  "Publish a post or thread to X RIGHT NOW (irreversible; --idempotency-key required)",
+  (y) => advancedSettingsOptions(accountOption(y)).option("text", { describe: "Text for a single post", type: "string" }).option("part", {
+    describe: "Thread part text (repeat the flag, 1-25 parts, in order)",
+    type: "string",
+    array: true
+  }).option("media", {
+    describe: "Comma list of image object_keys (from media:upload) to attach; single-post form only (max 4 images or 1 GIF)",
+    type: "string"
+  }).option("alt-text", {
+    describe: "Accessibility description for the attached image (single --media key only, max 1000 chars)",
+    type: "string"
+  }).option("parts-json", {
+    describe: 'Full parts array as JSON for threads with media: [{"text":"...","media":[{"object_key":"...","alt_text":"..."}]}]',
+    type: "string"
+  }).option("tag", {
+    describe: "Tag id to assign (repeat the flag, max 20; ids from tags:list)",
+    type: "string",
+    array: true
+  }).option("idempotency-key", {
+    describe: "REQUIRED (max 64 chars). Reuse the SAME key when retrying so a timed-out call cannot post twice; use a new key only for new content",
+    type: "string"
+  }).example('$0 posts:publish --text "Shipping now." --idempotency-key launch-2026-09-07', "Publish a single post").example('$0 posts:publish --part "1/ Hook" --part "2/ Detail" --idempotency-key thread-42', "Publish a thread").example('$0 posts:publish --text "Shipping now." --auto-retweet 6 --idempotency-key launch-2026-09-07', "Publish with an auto retweet"),
+  run(postsPublish)
+).command(
+  "scheduled:bulk-retime",
+  "Move up to 500 queued posts to new times in one transaction",
+  (y) => accountOption(y).option("moves-json", {
+    describe: 'Moves as JSON: [{"id":"abc","scheduled_for":"2026-09-08T15:00:00Z"}] (max 500, each time 60s+ ahead)',
+    type: "string"
+  }).example(`$0 scheduled:bulk-retime --moves-json '[{"id":"abc","scheduled_for":"2026-09-08T15:00:00Z"}]'`, "Retime one queued post"),
+  run(scheduledBulkRetime)
+).command(
+  "scheduled:bulk-auto-retweet",
+  "Turn Auto Retweet on for up to 100 queued posts that do not have it yet",
+  (y) => accountOption(y).option("ids", { describe: "Comma list of post ids (max 100, from scheduled:list)", type: "string" }).option("auto-retweet", { describe: "Retweet each post this many hours after it goes live (1-12), required" }).option("auto-retweet-remove", { describe: "Remove the retweet this many hours later (1-12)" }).example("$0 scheduled:bulk-auto-retweet --ids abc,def --auto-retweet 6", "Auto retweet two queued posts after 6 hours"),
+  run(scheduledBulkAutoRetweet)
+).command(
+  "scheduled:bulk-delete",
+  "Delete up to 100 QUEUED posts and refund their post quota (sent posts and drafts are left alone)",
+  (y) => accountOption(y).option("ids", { describe: "Comma list of post ids (max 100, from scheduled:list)", type: "string" }).example("$0 scheduled:bulk-delete --ids abc,def", "Delete two queued posts"),
+  run(scheduledBulkDelete)
 ).command(
   "plug-templates:list",
   "List your auto-plug reply templates (id, text, has_media) for --auto-plug",
@@ -1563,6 +3303,34 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   "Remove a product by id (reversible by re-adding the same url)",
   (y) => accountOption(y).positional("id", { describe: "Product id (from context:products)", type: "string" }),
   run(contextProductsDelete)
+).command(
+  "context:products:replace",
+  "Replace the WHOLE product list with a JSON array (max 5); products missing from it are removed",
+  (y) => accountOption(y).option("json", {
+    describe: `JSON array of products, e.g. '[{"url":"https://superx.so","name":"SuperX"}]' ('[]' removes every product)`,
+    type: "string",
+    demandOption: true
+  }).example(
+    `$0 context:products:replace --json '[{"url":"https://superx.so","name":"SuperX"}]'`,
+    "Make SuperX the only product"
+  ).epilogue(
+    "CAUTION: this is a full replace by url. Read the current list with context:products first and send every product the account should keep; to change one product without touching the others, use context:products:set."
+  ),
+  run(contextProductsReplace)
+).command(
+  "context:regenerate-style-guide",
+  "Rebuild the generated style guide from the account's recent posts (free, once an hour)",
+  (y) => accountOption(y).example("$0 context:regenerate-style-guide", "Rewrite the guide for the main account").epilogue(
+    "Costs no AI credits. Your manual style-guide overrides (context:set --style-audience / --style-vocabulary) are left alone and keep outranking the generated guide. An account with fewer than 5 recent posts stored is read live, which draws on a platform-wide fair-use ceiling."
+  ),
+  run(contextRegenerateStyleGuide)
+).command(
+  "context:scrape-product <id>",
+  "Re-read a saved product's page and refresh its stored details (free)",
+  (y) => accountOption(y).positional("id", { describe: "Product id (from context:products)", type: "string" }).example("$0 context:scrape-product 3", "Refresh product 3 from its own url").epilogue(
+    "The url comes from the saved product, so change it with context:products:set first if it moved. Costs no AI credits, and runs on the account's allowance of 20 page reads a day, shared with the SuperX app."
+  ),
+  run(contextScrapeProduct)
 ).command(
   "queue:get",
   "Show the account's posting schedule: predefined time slots and the timezone they run in",
@@ -1649,15 +3417,74 @@ var advancedSettingsOptions = (y) => y.option("auto-retweet", {
   "Pull a scheduled article back to draft (quota refunds)",
   (y) => y.positional("id", { describe: "Article id", type: "string" }),
   run(articlesUnschedule)
+).command(
+  "articles:cover-styles",
+  "List the article cover styles saved in the SuperX app (ids for --style-id)",
+  (y) => accountOption(y),
+  run(articlesCoverStyles)
 ).command(
   "articles:cover <id>",
   "Generate an AI cover for an article (60-100s, spends AI credits)",
-  (y) => y.positional("id", { describe: "Article id (needs a title)", type: "string" }).option("style", { describe: "Style description steering the artwork (max 8000 chars)", type: "string" }).option("attach", {
+  (y) => y.positional("id", { describe: "Article id (needs a title)", type: "string" }).option("style", { describe: "Style description steering the artwork (max 8000 chars)", type: "string" }).option("style-id", {
+    describe: "Saved cover style id (from articles:cover-styles); not with --style",
+    type: "string"
+  }).option("attach", {
     describe: "Attach the result as the article's cover (use --no-attach to skip)",
     type: "boolean",
     default: true
-  }),
+  }).example("$0 articles:cover abc123 --style-id sty_9f2", "Generate in a saved style"),
   run(articlesCover)
+).command(
+  "dm:campaign",
+  "Queue direct messages to a list of X users (nothing is sent by this command)",
+  (y) => accountOption(y).option("recipients", {
+    describe: 'JSON file of [{ "x_user_id", "handle"?, "name"?, "message"? }]; --recipients=- reads stdin',
+    type: "string",
+    demandOption: true
+  }).option("message", {
+    describe: "The shared message (1-1000). [name], [first] and [handle] are filled per recipient",
+    type: "string"
+  }).option("spread", {
+    describe: "Spread what today's allowance cannot hold over the coming days instead of skipping it",
+    type: "boolean"
+  }).option("idempotency-key", {
+    describe: "Reuse the same key on a retry so one campaign is never queued twice",
+    type: "string"
+  }).example(
+    '$0 dm:campaign --recipients people.json --message "Hey [first], loved your post"',
+    "Queue a campaign from a file"
+  ).epilogue(
+    "NOTHING IS SENT BY THIS COMMAND. The messages go into your DM queue and the SuperX app sends them within your daily and monthly DM limits, so the reply is counts, not deliveries. People you messaged in the last 24 hours are skipped and your own account is never messaged. You are responsible for these messages under X's automation rules. Check your allowances with dm:limits and cancel the unsent ones with dm:cancel."
+  ),
+  run(dmCampaign)
+).command(
+  "dm:campaign-status <id>",
+  "Show one campaign's status counts and its individual messages",
+  (y) => accountOption(
+    y.positional("id", { describe: "Campaign id (from dm:campaign)", type: "string" })
+  ),
+  run(dmCampaignStatus)
+).command(
+  "dm:cancel <id>",
+  "Cancel a campaign's unsent messages (sent ones cannot be recalled)",
+  (y) => accountOption(
+    y.positional("id", { describe: "Campaign id (from dm:campaign)", type: "string" })
+  ),
+  run(dmCancel)
+).command(
+  "dm:queue",
+  "List the account's queued and recently sent direct messages",
+  (y) => accountOption(y).option("limit", { describe: "Rows per page (max 200, default 50)", type: "number" }).option("offset", { describe: "Rows to skip", type: "number" }).option("status", {
+    describe: "Only rows in this state",
+    type: "string",
+    choices: ["pending", "sending", "sent", "failed", "skipped"]
+  }).option("campaign", { describe: "Only rows from this campaign id", type: "string" }).example("$0 dm:queue --status pending", "What is still waiting to go out"),
+  run(dmQueue)
+).command(
+  "dm:limits",
+  "Show the account's DM allowances and how much of each is used (free)",
+  (y) => accountOption(y),
+  run(dmLimits)
 ).command("docs", "Print the SuperX API quickstart (markdown, no auth needed)", {}, run(docs)).demandCommand(1, "Specify a command. Run: superx --help").strict().help().alias("h", "help").version().wrap(Math.min(100, process.stdout.columns || 100)).fail((msg, err) => {
   if (err) throw err;
   note(msg || "Invalid usage. Run: superx --help");