@brew.new/cli 0.6.0 → 0.9.0

package/dist/bin.js

@@ -31,6 +31,14 @@ var CliApiError = class extends Error {
   suggestion;
   docs;
   requestId;
+  /**
+   * The envelope's `details` object when the API sent one — for a
+   * trigger-fire `payload_mismatch` that is `{ errors[], warnings[],
+   * payloadSchema, … }`, naming every field the payload got wrong.
+   */
+  details;
+  /** The parsed response body exactly as received (`undefined` if not JSON). */
+  body;
   constructor(input) {
     super(input.message);
     this.status = input.status;
@@ -40,8 +48,38 @@ var CliApiError = class extends Error {
     this.suggestion = input.suggestion;
     this.docs = input.docs;
     this.requestId = input.requestId;
+    this.details = input.details;
+    this.body = input.body;
   }
 };
+function errorTypeForStatus(status) {
+  switch (status) {
+    case 401:
+      return "authentication_error";
+    case 402:
+      return "payment_required";
+    case 403:
+      return "authorization_error";
+    case 404:
+      return "not_found";
+    case 409:
+      return "conflict";
+    case 429:
+      return "rate_limit";
+    case 501:
+      return "not_implemented";
+    case 503:
+      return "service_unavailable";
+    default:
+      return status >= 400 && status < 500 ? "invalid_request" : "internal_error";
+  }
+}
+function suggestionForStatus(status) {
+  if (status === 408 || status === 429 || status >= 500) {
+    return "Retry the request. If it keeps failing, contact support.";
+  }
+  return "Fix the request before sending it again \u2014 the same request fails the same way. See `details` for the specifics when present.";
+}
 var ConfirmationRequiredError = class extends Error {
   envelope;
   constructor(envelope) {
@@ -67,6 +105,7 @@ function toExitCode(error) {
 }
 function toErrorEnvelope(error) {
   if (error instanceof BrewApiError || error instanceof CliApiError) {
+    const details = readErrorDetails(error);
     return {
       code: error.code,
       type: error.type,
@@ -75,6 +114,7 @@ function toErrorEnvelope(error) {
       ...error.suggestion ? { suggestion: error.suggestion } : {},
       ...error.docs ? { docs: error.docs } : {},
       ...error.requestId ? { requestId: error.requestId } : {},
+      ...details === void 0 ? {} : { details },
       status: error.status
     };
   }
@@ -134,7 +174,10 @@ function printError(ctx, error) {
 `);
     return;
   }
-  const lines = [`brew-cli: ${envelope.message}`];
+  const lines = [
+    `brew-cli: ${envelope.message}`,
+    ...formatDetailLines(envelope.details)
+  ];
   if (envelope.suggestion) {
     lines.push(envelope.suggestion);
   }
@@ -147,6 +190,29 @@ function printError(ctx, error) {
   ctx.io.stderr.write(`${lines.join("\n")}
 `);
 }
+function readErrorDetails(error) {
+  const details = error.details;
+  return isRecord(details) ? details : void 0;
+}
+function formatDetailLines(details) {
+  if (details === void 0) {
+    return [];
+  }
+  const issues = details.errors;
+  if (Array.isArray(issues) && issues.length > 0 && issues.every(isIssue)) {
+    return issues.map((issue) => {
+      const types = typeof issue.expectedType === "string" ? typeof issue.actualType === "string" ? ` (expected ${issue.expectedType}, got ${issue.actualType})` : ` (expected ${issue.expectedType})` : "";
+      return `  - ${issue.field}: ${issue.message}${types}`;
+    });
+  }
+  return [`Details: ${JSON.stringify(details)}`];
+}
+function isIssue(value) {
+  return isRecord(value) && typeof value.field === "string" && typeof value.message === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function apiErrorStatus(error) {
   if (error instanceof BrewApiError || error instanceof CliApiError) {
     return error.status;
@@ -215,7 +281,7 @@ function shellQuote(token) {
 
 // src/version.ts
 var CLI_NAME = "brew-cli";
-var CLI_VERSION = "0.6.0" ;
+var CLI_VERSION = "0.9.0" ;
 var CONFIG_KEYS = ["apiKey", "brandId", "apiUrl"];
 function isConfigKey(value) {
   return CONFIG_KEYS.includes(value);
@@ -286,6 +352,7 @@ var ORG_LEVEL_PATH_PREFIXES = [
   "/v1/brands",
   "/v1/usage",
   "/v1/templates",
+  "/v1/flows",
   "/v1/health",
   "/v1/help",
   "/v1/llms.txt",
@@ -586,6 +653,10 @@ var IDEMPOTENCY_FLAG = {
   flag: "--idempotency-key <key>",
   summary: "Idempotency-Key for safe retries (auto-generated otherwise)"
 };
+var NON_REPLAYING_IDEMPOTENCY_FLAG = {
+  flag: "--idempotency-key <key>",
+  summary: "Accepted for compatibility only: this route never replays, so a retry runs again"
+};
 var INPUT_FLAG = {
   flag: "--input <json>",
   summary: "Full JSON request body, or - to read stdin (flags override it)"
@@ -668,12 +739,111 @@ function renderAutomationRows(rows) {
   ]);
 }
 
+// src/commands/sends/list.ts
+var SEND_STATUS_SUMMARY = "scheduled | queued | running | paused | completed | partially_completed | failed | canceled";
+var sendsListCommand = defineCommand({
+  path: ["sends", "list"],
+  summary: "List sends (the unit of delivery and analytics) with lifetime stats",
+  sdkMethod: "sends.list",
+  route: { method: "GET", path: "/v1/sends" },
+  commandClass: "read",
+  flags: [
+    { flag: "--email <emailId>", summary: "Only sends of this design" },
+    { flag: "--kind <kind>", summary: "campaign | automation" },
+    { flag: "--automation <automationId>", summary: "Filter by automation" },
+    {
+      flag: "--automation-run <automationRunId>",
+      summary: "Deliveries of one automation run"
+    },
+    {
+      flag: "--audience-run <audienceRunId>",
+      summary: "Deliveries of one manual-audience run"
+    },
+    {
+      flag: "--trigger-instance <triggerInstanceId>",
+      summary: "Deliveries started by one fired trigger instance"
+    },
+    { flag: "--status <status>", summary: SEND_STATUS_SUMMARY },
+    {
+      flag: "--message-class <class>",
+      summary: "marketing | transactional"
+    },
+    {
+      flag: "--since <datetime>",
+      summary: "Inclusive lower bound on updatedAt (ISO-8601)"
+    },
+    {
+      flag: "--until <datetime>",
+      summary: "Inclusive upper bound on updatedAt (ISO-8601)"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
+  ],
+  examples: [
+    "brew-cli sends list --status completed",
+    "brew-cli sends list --email eml_1 --all --json",
+    "brew-cli sends list --automation-run arun_9f2kX"
+  ],
+  run: async ({ ctx, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const input = mergeInput(base, {
+      emailId: flagString(flags.email),
+      kind: flagString(flags.kind),
+      automationId: flagString(flags.automation),
+      automationRunId: flagString(flags.automationRun),
+      audienceRunId: flagString(flags.audienceRun),
+      triggerInstanceId: flagString(flags.triggerInstance),
+      status: flagString(flags.status),
+      messageClass: flagString(flags.messageClass),
+      from: flagString(flags.since),
+      to: flagString(flags.until),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    });
+    return await listSends(ctx, input, flags.all === true);
+  }
+});
+async function listSends(ctx, input, followCursor) {
+  const sends = ctx.client().sends;
+  if (followCursor) {
+    const rows = await collectAll(
+      ctx,
+      (cursor) => sends.list(
+        asSdkInput({
+          ...input,
+          ...cursor === void 0 ? {} : { cursor }
+        })
+      )
+    );
+    return {
+      data: { data: rows, pagination: { cursor: null, hasMore: false } },
+      human: renderSends(rows)
+    };
+  }
+  const result = await sends.list(asSdkInput(input));
+  return { data: result, human: renderSends(result.data) };
+}
+function renderSends(rows) {
+  if (rows.length === 0) {
+    return "No sends found.";
+  }
+  return renderTable(rows, [
+    { key: "sendId", header: "SEND" },
+    { key: "kind", header: "KIND" },
+    { key: "status", header: "STATUS" },
+    { key: "subject", header: "SUBJECT" }
+  ]);
+}
+
 // src/commands/analytics/campaigns.ts
 var analyticsCampaignsCommand = defineCommand({
   path: ["analytics", "campaigns"],
-  summary: "Lifetime per-campaign KPIs (sent, opened, clicked, bounced)",
-  sdkMethod: "analytics.campaigns",
-  route: { method: "GET", path: "/v1/analytics/campaigns" },
+  summary: "Lifetime per-campaign KPIs (`sends list --kind campaign`; stats ride each row)",
+  sdkMethod: null,
+  derivedFrom: "sends.list",
+  route: { method: "GET", path: "/v1/sends" },
   commandClass: "read",
   flags: [LIMIT_FLAG, CURSOR_FLAG, ALL_FLAG, INPUT_FLAG],
   examples: [
@@ -683,41 +853,207 @@ var analyticsCampaignsCommand = defineCommand({
   run: async ({ ctx, flags }) => {
     const base = await readJsonFlag(ctx, flags.input, "--input");
     const input = mergeInput(base, {
+      kind: "campaign",
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
-    const analytics = ctx.client().analytics;
-    if (flags.all === true) {
-      const rows = await collectAll(
-        ctx,
-        (cursor) => analytics.campaigns(
-          asSdkInput({
-            ...input,
-            ...cursor === void 0 ? {} : { cursor }
-          })
-        )
+    return await listSends(ctx, input, flags.all === true);
+  }
+});
+
+// src/lib/raw-request.ts
+async function rawRequest(ctx, request) {
+  const auth = resolveAuth({
+    globals: ctx.globals,
+    env: ctx.io.env,
+    ...request.allowAnonymous === true ? { allowAnonymous: true } : {}
+  });
+  const hasBody = request.body !== void 0;
+  const idempotencyKey = resolveRawIdempotencyKey(
+    request.method,
+    request.idempotencyKey
+  );
+  const headers = buildRawHeaders({
+    auth,
+    path: request.path,
+    hasJsonBody: hasBody,
+    idempotencyKey
+  });
+  const url = new URL(`${auth.apiUrl}${request.path}`);
+  for (const [key, value] of Object.entries(request.query ?? {})) {
+    if (value !== void 0) {
+      url.searchParams.set(key, value);
+    }
+  }
+  const response = await fetch(url, {
+    method: request.method,
+    headers,
+    ...hasBody ? { body: JSON.stringify(request.body) } : {},
+    ...request.signal === void 0 ? {} : { signal: request.signal }
+  });
+  const text = await response.text();
+  const parsed = tryParseJson(text);
+  if (!response.ok) {
+    throw responseToApiError(response, parsed);
+  }
+  if (parsed === void 0) {
+    throw new CliApiError({
+      status: response.status,
+      code: "UNEXPECTED_RESPONSE",
+      type: "internal_error",
+      message: "The API returned a non-JSON success response."
+    });
+  }
+  return parsed;
+}
+function resolveRawIdempotencyKey(method, provided) {
+  if (provided !== void 0 && provided !== "") {
+    return provided;
+  }
+  return method === "POST" ? crypto.randomUUID() : void 0;
+}
+function buildRawHeaders(input) {
+  const headers = new Headers({
+    authorization: `Bearer ${input.auth.apiKey}`,
+    "user-agent": `${CLI_NAME}/${CLI_VERSION}`,
+    accept: "application/json, text/plain;q=0.9"
+  });
+  if (input.hasJsonBody) {
+    headers.set("content-type", "application/json");
+  }
+  if (input.auth.brandId !== void 0 && !isOrgLevelPath(input.path)) {
+    headers.set("x-brand-id", input.auth.brandId);
+  }
+  if (input.idempotencyKey !== void 0 && input.idempotencyKey !== "") {
+    headers.set("idempotency-key", input.idempotencyKey);
+  }
+  return headers;
+}
+function responseToApiError(response, parsed) {
+  const requestId = response.headers.get("x-request-id") ?? void 0;
+  const record = isRecord2(parsed) ? parsed : void 0;
+  const standard = record !== void 0 && isRecord2(record.error) ? record.error : void 0;
+  const envelope = standard ?? record;
+  const readField = (key) => {
+    const value = envelope?.[key];
+    return typeof value === "string" ? value : void 0;
+  };
+  const param = readField("param");
+  const suggestion = readField("suggestion") ?? (envelope === void 0 ? void 0 : suggestionForStatus(response.status));
+  const docs = readField("docs");
+  const details = isRecord2(envelope?.details) ? envelope.details : void 0;
+  return new CliApiError({
+    status: response.status,
+    code: readField("code") ?? "HTTP_ERROR",
+    type: readField("type") ?? errorTypeForStatus(response.status),
+    message: readField("message") ?? `Request failed with status ${response.status}`,
+    ...param === void 0 ? {} : { param },
+    ...suggestion === void 0 ? {} : { suggestion },
+    ...docs === void 0 ? {} : { docs },
+    ...requestId === void 0 ? {} : { requestId },
+    ...details === void 0 ? {} : { details },
+    ...parsed === void 0 ? {} : { body: parsed }
+  });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+  }
+}
+
+// src/commands/analytics/event-counts.ts
+var analyticsEventCountsCommand = defineCommand({
+  path: ["analytics", "event-counts"],
+  summary: "Count email events per field and/or period (clicks per link, events per day, unsubscribe reasons)",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: { method: "GET", path: "/v1/analytics/events" },
+  commandClass: "read",
+  flags: [
+    {
+      flag: "--group-by <fields>",
+      summary: "One or two comma-separated fields: eventType, emailId, automationId, sendId, source, link, recipientDomain, unsubscribeReason"
+    },
+    {
+      flag: "--bucket <period>",
+      summary: "Count per UTC day, week (Monday start) or month"
+    },
+    { flag: "--since <datetime>", summary: "Window start (ISO-8601)" },
+    { flag: "--until <datetime>", summary: "Window end (ISO-8601)" },
+    {
+      flag: "--event-type <type>",
+      summary: "Only one email event type (e.g. clicked)"
+    },
+    { flag: "--send-id <sendId>", summary: "Only one send" },
+    { flag: "--email-id <emailId>", summary: "Only one design" },
+    {
+      flag: "--recipient <rules>",
+      summary: "CSV of recipient rules (max 10): an address, @domain, or substring; prefix ! to exclude"
+    },
+    INPUT_FLAG
+  ],
+  examples: [
+    "brew-cli analytics event-counts --send-id snd_123 --event-type clicked --group-by link",
+    "brew-cli analytics event-counts --group-by eventType --bucket day",
+    "brew-cli analytics event-counts --group-by unsubscribeReason --json"
+  ],
+  run: async ({ ctx, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const input = mergeInput(base, {
+      groupBy: flagString(flags.groupBy),
+      bucket: flagString(flags.bucket),
+      from: flagString(flags.since),
+      to: flagString(flags.until),
+      eventType: flagString(flags.eventType),
+      sendId: flagString(flags.sendId),
+      emailId: flagString(flags.emailId),
+      recipient: flagString(flags.recipient)
+    });
+    if (input.groupBy === void 0 && input.bucket === void 0) {
+      throw new CliUsageError(
+        "Pass --group-by, --bucket, or both (`analytics events` lists the rows)."
       );
-      return {
-        data: { data: rows, pagination: { cursor: null, hasMore: false } },
-        human: renderCampaigns(rows)
-      };
     }
-    const result = await analytics.campaigns(
-      asSdkInput(input)
-    );
-    return { data: result, human: renderCampaigns(result.data) };
+    const query = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (key === "cursor" || key === "limit") {
+        continue;
+      }
+      query[key] = value === void 0 || value === null ? void 0 : Array.isArray(value) ? value.map(String).join(",") : String(value);
+    }
+    const body = await rawRequest(ctx, {
+      method: "GET",
+      path: "/v1/analytics/events",
+      query
+    });
+    return { data: body, human: renderCounts(body) };
   }
 });
-function renderCampaigns(rows) {
-  if (rows.length === 0) {
-    return "No campaign analytics rows.";
-  }
-  return renderTable(rows, [
-    { key: "sendId", header: "SEND" },
-    { key: "title", header: "TITLE" },
-    { key: "status", header: "STATUS" },
-    { key: "sentAt", header: "SENT AT" }
+function renderCounts(body) {
+  if (body.groups.length === 0) {
+    return `No events counted (total ${body.count}).`;
+  }
+  const rows = body.groups.map((group) => ({
+    group: Object.entries(group.key ?? {}).map(([field, value]) => `${field}=${String(value)}`).join(" "),
+    ...group.bucket === void 0 ? {} : { bucket: group.bucket },
+    count: group.count
+  }));
+  const table = renderTable(rows, [
+    { key: "group", header: "GROUP" },
+    ...rows.some((row) => "bucket" in row) ? [{ key: "bucket", header: "PERIOD" }] : [],
+    { key: "count", header: "COUNT" }
   ]);
+  const footer = [
+    `total ${body.count}`,
+    body.otherCount > 0 ? `${body.otherCount} in unlisted groups` : "",
+    body.truncated ? `truncated (counted from ${body.coveredFrom ?? "?"})` : ""
+  ].filter(Boolean).join(" \xB7 ");
+  return `${table}
+${footer}`;
 }
 
 // src/commands/analytics/events.ts
@@ -730,7 +1066,10 @@ var analyticsEventsCommand = defineCommand({
   flags: [
     { flag: "--since <datetime>", summary: "Window start (ISO-8601)" },
     { flag: "--until <datetime>", summary: "Window end (ISO-8601)" },
-    { flag: "--recipient <email>", summary: "Filter by recipient email" },
+    {
+      flag: "--recipient <rules>",
+      summary: "CSV of recipient rules (max 10): an address, @domain, or substring; prefix ! to exclude"
+    },
     {
       flag: "--event-type <type>",
       summary: "Filter by event type (e.g. opened, clicked)"
@@ -751,7 +1090,7 @@ var analyticsEventsCommand = defineCommand({
     const input = mergeInput(base, {
       from: flagString(flags.since),
       to: flagString(flags.until),
-      recipientEmail: flagString(flags.recipient),
+      recipient: flagString(flags.recipient),
       eventType: flagString(flags.eventType),
       automationId: flagString(flags.automation),
       sendId: flagString(flags.send),
@@ -852,10 +1191,10 @@ var analyticsOverviewCommand = defineCommand({
 // src/commands/analytics/sends/get.ts
 var analyticsSendsGetCommand = defineCommand({
   path: ["analytics", "sends", "get"],
-  summary: "Fetch one send by id",
+  summary: "Fetch one send by id \u2014 the bare row (`sends get`)",
   sdkMethod: null,
-  derivedFrom: "analytics.sends.list",
-  route: { method: "GET", path: "/v1/analytics/sends" },
+  derivedFrom: "sends.get",
+  route: { method: "GET", path: "/v1/sends/{sendId}" },
   commandClass: "read",
   args: [
     {
@@ -875,46 +1214,54 @@ var analyticsSendsGetCommand = defineCommand({
     "brew-cli analytics sends get snd_123 --include events"
   ],
   run: async ({ ctx, args, flags }) => {
-    const sendId = args.sendId ?? "";
     const include = flagString(flags.include);
-    const result = await ctx.client().analytics.sends.list(
-      asSdkInput({
-        sendId,
-        ...include === void 0 ? {} : { include }
-      })
-    );
-    const send = result.data[0];
-    if (send === void 0) {
-      throw new CliApiError({
-        status: 404,
-        code: "SEND_NOT_FOUND",
-        type: "not_found",
-        message: `No send found for ${sendId}`,
-        suggestion: "List sends with `brew-cli analytics sends list`."
-      });
-    }
-    return { data: send };
+    return {
+      data: await ctx.client().sends.get(
+        args.sendId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
   }
 });
 
+// src/lib/compat.ts
+function singleRowPage(row) {
+  return { data: [row], pagination: { cursor: null, hasMore: false } };
+}
+function inputField(base, key) {
+  if (base === null || typeof base !== "object") {
+    return void 0;
+  }
+  const value = base[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function includeRidesDetailRead(getCommand, idFlag) {
+  const pairing = idFlag === void 0 ? "" : `, or pair it with ${idFlag}`;
+  return new CliUsageError(
+    `--include rides the detail read: use \`brew-cli ${getCommand} <id> --include \u2026\`${pairing}.`
+  );
+}
+
 // src/commands/analytics/sends/list.ts
 var analyticsSendsListCommand = defineCommand({
   path: ["analytics", "sends", "list"],
-  summary: "List campaign/automation sends with delivery stats",
-  sdkMethod: "analytics.sends.list",
-  route: { method: "GET", path: "/v1/analytics/sends" },
+  summary: "List campaign/automation sends with delivery stats (`sends list`)",
+  sdkMethod: null,
+  derivedFrom: "sends.list",
+  route: { method: "GET", path: "/v1/sends" },
   commandClass: "read",
   flags: [
-    { flag: "--send <sendId>", summary: "Fetch one send (single-row page)" },
-    { flag: "--email <emailId>", summary: "Filter by email design" },
     {
-      flag: "--include <tokens>",
-      summary: "Comma-separated expansions: events"
+      flag: "--send <sendId>",
+      summary: "0.6 shim: read ONE send as a single-row page (`sends get` is the real read)"
     },
     {
-      flag: "--status <status>",
-      summary: "scheduled | queued | sending | sent | failed | canceled"
+      flag: "--include <tokens>",
+      summary: "With --send only: detail includes (`events`)"
     },
+    { flag: "--email <emailId>", summary: "Filter by email design" },
+    { flag: "--kind <kind>", summary: "campaign | automation" },
+    { flag: "--status <status>", summary: SEND_STATUS_SUMMARY },
     { flag: "--since <datetime>", summary: "Window start (ISO-8601)" },
     { flag: "--until <datetime>", summary: "Window end (ISO-8601)" },
     LIMIT_FLAG,
@@ -923,108 +1270,86 @@ var analyticsSendsListCommand = defineCommand({
     INPUT_FLAG
   ],
   examples: [
-    "brew-cli analytics sends list --status sent",
-    "brew-cli analytics sends list --email em_123 --all --json"
+    "brew-cli analytics sends list --status completed",
+    "brew-cli analytics sends list --email eml_1 --all --json"
   ],
   run: async ({ ctx, flags }) => {
     const base = await readJsonFlag(ctx, flags.input, "--input");
+    const sendId = flagString(flags.send) ?? inputField(base, "sendId");
+    const include = flagString(flags.include) ?? inputField(base, "include");
+    if (sendId !== void 0) {
+      const row = await ctx.client().sends.get(sendId, include === void 0 ? void 0 : { include });
+      return { data: singleRowPage(row), human: renderSends([row]) };
+    }
+    if (include !== void 0) {
+      throw includeRidesDetailRead("sends get", "--send");
+    }
     const input = mergeInput(base, {
-      sendId: flagString(flags.send),
       emailId: flagString(flags.email),
-      include: flagString(flags.include),
+      kind: flagString(flags.kind),
       status: flagString(flags.status),
       from: flagString(flags.since),
       to: flagString(flags.until),
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
-    const sends = ctx.client().analytics.sends;
-    if (flags.all === true) {
-      const rows = await collectAll(
-        ctx,
-        (cursor) => sends.list(
-          asSdkInput({
-            ...input,
-            ...cursor === void 0 ? {} : { cursor }
-          })
-        )
-      );
-      return {
-        data: { data: rows, pagination: { cursor: null, hasMore: false } },
-        human: renderSends(rows)
-      };
-    }
-    const result = await sends.list(asSdkInput(input));
-    return { data: result, human: renderSends(result.data) };
+    return await listSends(ctx, input, flags.all === true);
   }
 });
-function renderSends(rows) {
-  if (rows.length === 0) {
-    return "No sends found.";
-  }
-  return renderTable(rows, [
-    { key: "sendId", header: "SEND" },
-    { key: "kind", header: "KIND" },
-    { key: "status", header: "STATUS" },
-    { key: "subject", header: "SUBJECT" }
-  ]);
-}
 
-// src/commands/analytics/trigger-instances/list.ts
-var analyticsTriggerInstancesListCommand = defineCommand({
-  path: ["analytics", "trigger-instances", "list"],
-  summary: "List fired-trigger instances (ingest + match history)",
-  sdkMethod: "analytics.triggerInstances.list",
-  route: { method: "GET", path: "/v1/analytics/trigger-instances" },
+// src/commands/automations/trigger-instances/list.ts
+var automationsTriggerInstancesListCommand = defineCommand({
+  path: ["automations", "trigger-instances", "list"],
+  summary: "List fired-trigger instances (the inbound-fire audit log); each row carries a lifecycle `state`",
+  sdkMethod: "automations.triggerInstances.list",
+  route: { method: "GET", path: "/v1/automations/trigger-instances" },
   commandClass: "read",
   flags: [
     {
       flag: "--trigger <triggerEventId>",
       summary: "Filter by trigger event"
     },
-    {
-      flag: "--trigger-instance <triggerInstanceId>",
-      summary: "Fetch one instance (single-row page)"
-    },
     LIMIT_FLAG,
     CURSOR_FLAG,
     ALL_FLAG,
     INPUT_FLAG
   ],
   examples: [
-    "brew-cli analytics trigger-instances list --trigger tev_123",
-    "brew-cli analytics trigger-instances list --all --json"
+    "brew-cli automations trigger-instances list --trigger tri_signup",
+    "brew-cli automations trigger-instances list --all --json"
   ],
   run: async ({ ctx, flags }) => {
     const base = await readJsonFlag(ctx, flags.input, "--input");
     const input = mergeInput(base, {
       triggerEventId: flagString(flags.trigger),
-      triggerInstanceId: flagString(flags.triggerInstance),
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
-    const triggerInstances = ctx.client().analytics.triggerInstances;
-    if (flags.all === true) {
-      const rows = await collectAll(
-        ctx,
-        (cursor) => triggerInstances.list(
-          asSdkInput({
-            ...input,
-            ...cursor === void 0 ? {} : { cursor }
-          })
-        )
-      );
-      return {
-        data: { data: rows, pagination: { cursor: null, hasMore: false } },
-        human: renderInstances(rows)
-      };
-    }
-    const result = await triggerInstances.list(
-      asSdkInput(input)
-    );
-    return { data: result, human: renderInstances(result.data) };
+    return await listTriggerInstances(ctx, input, flags.all === true);
   }
 });
+async function listTriggerInstances(ctx, input, followCursor) {
+  const triggerInstances = ctx.client().automations.triggerInstances;
+  if (followCursor) {
+    const rows = await collectAll(
+      ctx,
+      (cursor) => triggerInstances.list(
+        asSdkInput({
+          ...input,
+          ...cursor === void 0 ? {} : { cursor }
+        })
+      )
+    );
+    return {
+      data: { data: rows, pagination: { cursor: null, hasMore: false } },
+      human: renderInstances(rows)
+    };
+  }
+  const result = await triggerInstances.list(
+    asSdkInput(input)
+  );
+  return { data: result, human: renderInstances(result.data) };
+}
 function renderInstances(rows) {
   if (rows.length === 0) {
     return "No trigger instances found.";
@@ -1037,102 +1362,47 @@ function renderInstances(rows) {
   ]);
 }
 
-// src/lib/raw-request.ts
-async function rawRequest(ctx, request) {
-  const auth = resolveAuth({
-    globals: ctx.globals,
-    env: ctx.io.env,
-    ...request.allowAnonymous === true ? { allowAnonymous: true } : {}
-  });
-  const hasBody = request.body !== void 0;
-  const idempotencyKey = resolveRawIdempotencyKey(
-    request.method,
-    request.idempotencyKey
-  );
-  const headers = buildRawHeaders({
-    auth,
-    path: request.path,
-    hasJsonBody: hasBody,
-    idempotencyKey
-  });
-  const url = new URL(`${auth.apiUrl}${request.path}`);
-  for (const [key, value] of Object.entries(request.query ?? {})) {
-    if (value !== void 0) {
-      url.searchParams.set(key, value);
+// src/commands/analytics/trigger-instances/list.ts
+var analyticsTriggerInstancesListCommand = defineCommand({
+  path: ["analytics", "trigger-instances", "list"],
+  summary: "List fired-trigger instances with their lifecycle `state` (`automations trigger-instances list`)",
+  sdkMethod: null,
+  derivedFrom: "automations.triggerInstances.list",
+  route: { method: "GET", path: "/v1/automations/trigger-instances" },
+  commandClass: "read",
+  flags: [
+    {
+      flag: "--trigger <triggerEventId>",
+      summary: "Filter by trigger event"
+    },
+    {
+      flag: "--trigger-instance <triggerInstanceId>",
+      summary: "0.6 shim: read ONE instance as a single-row page (`automations trigger-instances get` is the real read)"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
+  ],
+  examples: [
+    "brew-cli analytics trigger-instances list --trigger tri_signup",
+    "brew-cli analytics trigger-instances list --all --json"
+  ],
+  run: async ({ ctx, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const triggerInstanceId = flagString(flags.triggerInstance) ?? inputField(base, "triggerInstanceId");
+    if (triggerInstanceId !== void 0) {
+      const row = await ctx.client().automations.triggerInstances.get(triggerInstanceId);
+      return { data: singleRowPage(row), human: renderInstances([row]) };
     }
-  }
-  const response = await fetch(url, {
-    method: request.method,
-    headers,
-    ...hasBody ? { body: JSON.stringify(request.body) } : {},
-    ...request.signal === void 0 ? {} : { signal: request.signal }
-  });
-  const text = await response.text();
-  const parsed = tryParseJson(text);
-  if (!response.ok) {
-    throw responseToApiError(response, parsed);
-  }
-  if (parsed === void 0) {
-    throw new CliApiError({
-      status: response.status,
-      code: "UNEXPECTED_RESPONSE",
-      type: "internal_error",
-      message: "The API returned a non-JSON success response."
+    const input = mergeInput(base, {
+      triggerEventId: flagString(flags.trigger),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
     });
+    return await listTriggerInstances(ctx, input, flags.all === true);
   }
-  return parsed;
-}
-function resolveRawIdempotencyKey(method, provided) {
-  if (provided !== void 0 && provided !== "") {
-    return provided;
-  }
-  return method === "POST" ? crypto.randomUUID() : void 0;
-}
-function buildRawHeaders(input) {
-  const headers = new Headers({
-    authorization: `Bearer ${input.auth.apiKey}`,
-    "user-agent": `${CLI_NAME}/${CLI_VERSION}`,
-    accept: "application/json, text/plain;q=0.9"
-  });
-  if (input.hasJsonBody) {
-    headers.set("content-type", "application/json");
-  }
-  if (input.auth.brandId !== void 0 && !isOrgLevelPath(input.path)) {
-    headers.set("x-brand-id", input.auth.brandId);
-  }
-  if (input.idempotencyKey !== void 0 && input.idempotencyKey !== "") {
-    headers.set("idempotency-key", input.idempotencyKey);
-  }
-  return headers;
-}
-function responseToApiError(response, parsed) {
-  const requestId = response.headers.get("x-request-id") ?? void 0;
-  const record = parsed !== null && typeof parsed === "object" ? parsed : void 0;
-  const envelope = record !== void 0 && record.error !== null && typeof record.error === "object" ? record.error : record;
-  const readField = (key) => {
-    const value = envelope?.[key];
-    return typeof value === "string" ? value : void 0;
-  };
-  const param = readField("param");
-  const suggestion = readField("suggestion");
-  const docs = readField("docs");
-  return new CliApiError({
-    status: response.status,
-    code: readField("code") ?? "HTTP_ERROR",
-    type: readField("type") ?? "internal_error",
-    message: readField("message") ?? `Request failed with status ${response.status}`,
-    ...param === void 0 ? {} : { param },
-    ...suggestion === void 0 ? {} : { suggestion },
-    ...docs === void 0 ? {} : { docs },
-    ...requestId === void 0 ? {} : { requestId }
-  });
-}
-function tryParseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-  }
-}
+});
 
 // src/commands/api.ts
 var METHODS = ["GET", "POST", "PATCH", "DELETE"];
@@ -1276,7 +1546,9 @@ var apiKeysCreateCommand = defineCommand({
       summary: "Bind the NEW key to this brand id (omit for an organization-wide key); not the acting --brand"
     },
     INPUT_FLAG,
-    IDEMPOTENCY_FLAG
+    // The route never replays (a replay would disclose the plaintext key
+    // again): a retry mints a second key, whatever the key says.
+    NON_REPLAYING_IDEMPOTENCY_FLAG
   ],
   examples: [
     "brew-cli api-keys create --name CI --permissions emails domains",
@@ -1320,9 +1592,31 @@ var apiKeysListCommand = defineCommand({
   sdkMethod: "apiKeys.list",
   route: { method: "GET", path: "/v1/api-keys" },
   commandClass: "read",
+  flags: [LIMIT_FLAG, CURSOR_FLAG, ALL_FLAG],
   examples: ["brew-cli api-keys list", "brew-cli api-keys list --json"],
-  run: async ({ ctx }) => {
-    const result = await ctx.client().apiKeys.list();
+  run: async ({ ctx, flags }) => {
+    const limit = flagInt(flags.limit, "--limit");
+    const cursor = flagString(flags.cursor);
+    if (limit === void 0 && cursor === void 0 && flags.all !== true) {
+      const result2 = await ctx.client().apiKeys.list();
+      return { data: result2, human: renderApiKeys(result2.data) };
+    }
+    const page = (after) => rawRequest(ctx, {
+      method: "GET",
+      path: "/v1/api-keys",
+      query: {
+        limit: limit === void 0 ? void 0 : String(limit),
+        cursor: after
+      }
+    });
+    if (flags.all === true) {
+      const rows = await collectAll(ctx, (next) => page(next ?? cursor));
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } },
+        human: renderApiKeys(rows)
+      };
+    }
+    const result = await page(cursor);
     return { data: result, human: renderApiKeys(result.data) };
   }
 });
@@ -1479,10 +1773,9 @@ var audiencesFromEventsCommand = defineCommand({
 // src/commands/audiences/get.ts
 var audiencesGetCommand = defineCommand({
   path: ["audiences", "get"],
-  summary: "Fetch one audience segment by id",
-  sdkMethod: null,
-  derivedFrom: "audiences.list",
-  route: { method: "GET", path: "/v1/audiences" },
+  summary: "Fetch one audience segment by id \u2014 the bare row",
+  sdkMethod: "audiences.get",
+  route: { method: "GET", path: "/v1/audiences/{audienceId}" },
   commandClass: "read",
   args: [
     { name: "audienceId", summary: "Audience id to fetch", isRequired: true }
@@ -1490,42 +1783,35 @@ var audiencesGetCommand = defineCommand({
   flags: [
     {
       flag: "--include <tokens>",
-      summary: "Comma-separated expansions: count"
+      summary: "Comma-separated expansions: count, build"
     }
   ],
-  examples: ["brew-cli audiences get aud_3k9sQ"],
+  examples: [
+    "brew-cli audiences get aud_3k9sQ",
+    "brew-cli audiences get aud_3k9sQ --include count,build"
+  ],
   run: async ({ ctx, args, flags }) => {
-    const audienceId = args.audienceId ?? "";
     const include = flagString(flags.include);
-    const result = await ctx.client().audiences.list({
-      audienceId,
-      ...include === void 0 ? {} : { include }
-    });
-    const audience = result.data[0];
-    if (audience === void 0) {
-      throw new CliApiError({
-        status: 404,
-        code: "AUDIENCE_NOT_FOUND",
-        type: "not_found",
-        message: `No audience found for ${audienceId}`,
-        suggestion: "List audiences with `brew-cli audiences list`."
-      });
-    }
-    return { data: audience };
+    return {
+      data: await ctx.client().audiences.get(
+        args.audienceId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
   }
 });
 
 // src/commands/audiences/list.ts
 var audiencesListCommand = defineCommand({
   path: ["audiences", "list"],
-  summary: "List audience segments",
+  summary: "List audience segments; one segment is `audiences get`",
   sdkMethod: "audiences.list",
   route: { method: "GET", path: "/v1/audiences" },
   commandClass: "read",
   flags: [
     {
       flag: "--include <tokens>",
-      summary: "Comma-separated expansions: count"
+      summary: "0.6 flag: includes ride the detail read now (`audiences get --include count,build`)"
     },
     LIMIT_FLAG,
     CURSOR_FLAG,
@@ -1534,13 +1820,15 @@ var audiencesListCommand = defineCommand({
   ],
   examples: [
     "brew-cli audiences list",
-    "brew-cli audiences list --include count --limit 10",
+    "brew-cli audiences list --limit 10",
     "brew-cli audiences list --all --json"
   ],
   run: async ({ ctx, flags }) => {
     const base = await readJsonFlag(ctx, flags.input, "--input");
+    if ((flagString(flags.include) ?? inputField(base, "include")) !== void 0) {
+      throw includeRidesDetailRead("audiences get");
+    }
     const input = mergeInput(base, {
-      include: flagString(flags.include),
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
@@ -1607,16 +1895,45 @@ var audiencesUpdateCommand = defineCommand({
   }
 });
 
-// src/commands/automations/audience-runs/control.ts
-var automationsAudienceRunsControlCommand = defineCommand({
-  path: ["automations", "audience-runs", "control"],
-  summary: "Pause, resume, or cancel an in-flight manual-audience run",
-  sdkMethod: "automations.audienceRuns.control",
+// src/commands/automations/audience-runs/cancel.ts
+var automationsAudienceRunsCancelCommand = defineCommand({
+  path: ["automations", "audience-runs", "cancel"],
+  summary: "Cancel a manual-audience run for good \u2014 it can never be resumed",
+  sdkMethod: "automations.audienceRuns.cancel",
   route: {
     method: "POST",
-    path: "/v1/automations/audience-runs/{audienceRunId}/control"
+    path: "/v1/automations/audience-runs/{audienceRunId}/cancel"
   },
   commandClass: "destructive",
+  args: [
+    {
+      name: "audienceRunId",
+      summary: "Audience run id to cancel",
+      isRequired: true
+    }
+  ],
+  flags: [IDEMPOTENCY_FLAG],
+  examples: ["brew-cli automations audience-runs cancel arun_01HZ --yes"],
+  confirmSummary: ({ args }) => `Cancel audience run ${args.audienceRunId ?? ""} for good. Emails already sent are not recalled, and a canceled run cannot be resumed.`,
+  run: async ({ ctx, args, flags }) => ({
+    data: await ctx.client().automations.audienceRuns.cancel(
+      args.audienceRunId ?? "",
+      requestOptions(flags)
+    )
+  })
+});
+
+// src/commands/automations/audience-runs/control.ts
+var automationsAudienceRunsControlCommand = defineCommand({
+  path: ["automations", "audience-runs", "control"],
+  summary: "Pause, resume, or cancel an in-flight manual-audience run (0.6 form of `audience-runs pause|resume|cancel`)",
+  sdkMethod: null,
+  derivedFrom: [
+    "automations.audienceRuns.pause",
+    "automations.audienceRuns.resume",
+    "automations.audienceRuns.cancel"
+  ],
+  commandClass: "destructive",
   args: [
     {
       name: "audienceRunId",
@@ -1628,7 +1945,8 @@ var automationsAudienceRunsControlCommand = defineCommand({
     {
       flag: "--action <action>",
       summary: "pause (resumable) | resume | cancel (final)"
-    }
+    },
+    IDEMPOTENCY_FLAG
   ],
   examples: [
     "brew-cli automations audience-runs control arun_01HZ --action pause",
@@ -1637,58 +1955,182 @@ var automationsAudienceRunsControlCommand = defineCommand({
   // Only cancel is irreversible; pause and resume proceed ungated.
   confirmSummary: ({ args, flags }) => flagString(flags.action) === "cancel" ? `Cancel audience run ${args.audienceRunId ?? ""} for good. Emails already sent are not recalled, and a canceled run cannot be resumed.` : void 0,
   run: async ({ ctx, args, flags }) => {
-    const action = flagString(flags.action);
-    if (action === void 0) {
-      throw new CliUsageError("--action is required: pause, resume, or cancel.");
+    const audienceRuns = ctx.client().automations.audienceRuns;
+    const audienceRunId = args.audienceRunId ?? "";
+    const options = requestOptions(flags);
+    switch (flagString(flags.action)) {
+      case "pause":
+        return { data: await audienceRuns.pause(audienceRunId, options) };
+      case "resume":
+        return { data: await audienceRuns.resume(audienceRunId, options) };
+      case "cancel":
+        return { data: await audienceRuns.cancel(audienceRunId, options) };
+      default:
+        throw new CliUsageError(
+          "--action is required: pause, resume, or cancel."
+        );
     }
-    return {
-      data: await ctx.client().automations.audienceRuns.control(
-        asSdkInput({
-          audienceRunId: args.audienceRunId ?? "",
-          action
-        })
-      )
-    };
   }
 });
 
+// src/commands/automations/audience-runs/get.ts
+var automationsAudienceRunsGetCommand = defineCommand({
+  path: ["automations", "audience-runs", "get"],
+  summary: "Fetch one manual-audience run by id \u2014 the bare row",
+  sdkMethod: "automations.audienceRuns.get",
+  route: {
+    method: "GET",
+    path: "/v1/automations/audience-runs/{audienceRunId}"
+  },
+  commandClass: "read",
+  args: [
+    {
+      name: "audienceRunId",
+      summary: "Audience run id to fetch",
+      isRequired: true
+    }
+  ],
+  examples: ["brew-cli automations audience-runs get arun_01HZ"],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().automations.audienceRuns.get(args.audienceRunId ?? "")
+  })
+});
+
 // src/commands/automations/audience-runs/list.ts
 var automationsAudienceRunsListCommand = defineCommand({
   path: ["automations", "audience-runs", "list"],
-  summary: "List manual-audience runs (newest first)",
+  summary: "List manual-audience runs, newest first; one run is `automations audience-runs get`",
   sdkMethod: "automations.audienceRuns.list",
   route: { method: "GET", path: "/v1/automations/audience-runs" },
   commandClass: "read",
-  // The spec paginates by --limit only: no cursor, and the response carries
-  // no pagination envelope, so there is no --all here.
   flags: [
     {
-      flag: "--audience-run-id <id>",
-      summary: "Fetch a single audience run by id"
+      flag: "--automation <automationId>",
+      summary: "Only runs of this automation"
+    },
+    {
+      flag: "--automation-id <automationId>",
+      summary: "0.6 alias of --automation"
+    },
+    {
+      flag: "--audience-run-id <audienceRunId>",
+      summary: "0.6 shim: read ONE run as a single-row page (`automations audience-runs get` is the real read)"
     },
     {
-      flag: "--automation-id <id>",
-      summary: "Filter runs to a single automation"
+      flag: "--status <status>",
+      summary: "queued | scheduled | running | paused | completed | failed | canceled"
     },
-    { flag: "--limit <n>", summary: "Max rows, 1-200 (default 50)" }
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
   ],
   examples: [
     "brew-cli automations audience-runs list",
-    "brew-cli automations audience-runs list --automation-id auto_abc --limit 20"
+    "brew-cli automations audience-runs list --automation am_123 --status running"
   ],
   run: async ({ ctx, flags }) => {
-    const limit = flagInt(flags.limit, "--limit");
-    return {
-      data: await ctx.client().automations.audienceRuns.list(
-        asSdkInput({
-          audienceRunId: flagString(flags.audienceRunId),
-          automationId: flagString(flags.automationId),
-          limit
-        })
-      )
-    };
+    const audienceRuns = ctx.client().automations.audienceRuns;
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const audienceRunId = flagString(flags.audienceRunId) ?? inputField(base, "audienceRunId");
+    if (audienceRunId !== void 0) {
+      const row = await audienceRuns.get(audienceRunId);
+      return { data: singleRowPage(row), human: renderAudienceRuns([row]) };
+    }
+    const input = mergeInput(base, {
+      automationId: flagString(flags.automation) ?? flagString(flags.automationId),
+      status: flagString(flags.status),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    });
+    if (flags.all === true) {
+      const rows = await collectAll(
+        ctx,
+        (cursor) => audienceRuns.list(
+          asSdkInput({
+            ...input,
+            ...cursor === void 0 ? {} : { cursor }
+          })
+        )
+      );
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } },
+        human: renderAudienceRuns(rows)
+      };
+    }
+    const result = await audienceRuns.list(
+      asSdkInput(input)
+    );
+    return { data: result, human: renderAudienceRuns(result.data) };
   }
 });
+function renderAudienceRuns(rows) {
+  if (rows.length === 0) {
+    return "No audience runs found.";
+  }
+  return renderTable(rows, [
+    { key: "audienceRunId", header: "AUDIENCE RUN" },
+    { key: "automationId", header: "AUTOMATION" },
+    { key: "status", header: "STATUS" },
+    { key: "totalRecipients", header: "RECIPIENTS" }
+  ]);
+}
+
+// src/commands/automations/audience-runs/pause.ts
+var automationsAudienceRunsPauseCommand = defineCommand({
+  path: ["automations", "audience-runs", "pause"],
+  summary: "Pause a running manual-audience run at its next step boundary (resumable)",
+  sdkMethod: "automations.audienceRuns.pause",
+  route: {
+    method: "POST",
+    path: "/v1/automations/audience-runs/{audienceRunId}/pause"
+  },
+  commandClass: "write",
+  args: [
+    {
+      name: "audienceRunId",
+      summary: "Audience run id to pause",
+      isRequired: true
+    }
+  ],
+  flags: [IDEMPOTENCY_FLAG],
+  examples: ["brew-cli automations audience-runs pause arun_01HZ"],
+  run: async ({ ctx, args, flags }) => ({
+    data: await ctx.client().automations.audienceRuns.pause(
+      args.audienceRunId ?? "",
+      requestOptions(flags)
+    )
+  })
+});
+
+// src/commands/automations/audience-runs/resume.ts
+var automationsAudienceRunsResumeCommand = defineCommand({
+  path: ["automations", "audience-runs", "resume"],
+  summary: "Resume a paused manual-audience run, or restart a failed one from its first undelivered send",
+  sdkMethod: "automations.audienceRuns.resume",
+  route: {
+    method: "POST",
+    path: "/v1/automations/audience-runs/{audienceRunId}/resume"
+  },
+  commandClass: "write",
+  args: [
+    {
+      name: "audienceRunId",
+      summary: "Audience run id to resume",
+      isRequired: true
+    }
+  ],
+  flags: [IDEMPOTENCY_FLAG],
+  // `resumedFrom` on the response reports which case ran: `paused` or
+  // `failed`. A failed restart never resends a step the failed run finished.
+  examples: ["brew-cli automations audience-runs resume arun_01HZ"],
+  run: async ({ ctx, args, flags }) => ({
+    data: await ctx.client().automations.audienceRuns.resume(
+      args.audienceRunId ?? "",
+      requestOptions(flags)
+    )
+  })
+});
 
 // src/commands/automations/create.ts
 var automationsCreateCommand = defineCommand({
@@ -1755,10 +2197,9 @@ var automationsDeleteCommand = defineCommand({
 // src/commands/automations/get.ts
 var automationsGetCommand = defineCommand({
   path: ["automations", "get"],
-  summary: "Fetch one automation by id",
-  sdkMethod: null,
-  derivedFrom: "automations.list",
-  route: { method: "GET", path: "/v1/automations" },
+  summary: "Fetch one automation by id \u2014 the bare row, lean by default",
+  sdkMethod: "automations.get",
+  route: { method: "GET", path: "/v1/automations/{automationId}" },
   commandClass: "read",
   args: [
     {
@@ -1770,7 +2211,7 @@ var automationsGetCommand = defineCommand({
   flags: [
     {
       flag: "--include <tokens>",
-      summary: "Comma-separated expansions: graph | versions"
+      summary: "Comma-separated expansions: graph, versions"
     }
   ],
   examples: [
@@ -1778,23 +2219,13 @@ var automationsGetCommand = defineCommand({
     "brew-cli automations get am_123 --include graph,versions"
   ],
   run: async ({ ctx, args, flags }) => {
-    const automationId = args.automationId ?? "";
     const include = flagString(flags.include);
-    const result = await ctx.client().automations.list({
-      automationId,
-      ...include === void 0 ? {} : { include }
-    });
-    const automation = result.data[0];
-    if (automation === void 0) {
-      throw new CliApiError({
-        status: 404,
-        code: "AUTOMATION_NOT_FOUND",
-        type: "not_found",
-        message: `No automation found for ${automationId}`,
-        suggestion: "List automations with `brew-cli automations list`."
-      });
-    }
-    return { data: automation };
+    return {
+      data: await ctx.client().automations.get(
+        args.automationId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
   }
 });
 
@@ -1918,7 +2349,7 @@ var automationsRunCommand = defineCommand({
   ],
   confirmSummary: ({ args, flags }) => {
     const inline = parseInlineInput(flags.input);
-    if (flags.dryRun === true || inline?.dry_run === true) {
+    if (flags.dryRun === true || inline?.dryRun === true) {
       return;
     }
     const scheduleAt = flagString(flags.scheduleAt) ?? asString(inline?.scheduledAt);
@@ -1928,8 +2359,7 @@ var automationsRunCommand = defineCommand({
   run: async ({ ctx, args, flags }) => {
     const base = await readJsonFlag(ctx, flags.input, "--input");
     const input = mergeInput(base, {
-      // The spec field is snake_case, unlike the rest of the API surface.
-      dry_run: flags.dryRun === true ? true : void 0,
+      dryRun: flags.dryRun === true ? true : void 0,
       scheduledAt: flagString(flags.scheduleAt)
     });
     return {
@@ -1957,22 +2387,89 @@ function asString(value) {
   return typeof value === "string" && value !== "" ? value : void 0;
 }
 
+// src/commands/automations/runs/cancel.ts
+var automationsRunsCancelCommand = defineCommand({
+  path: ["automations", "runs", "cancel"],
+  summary: "Cancel one in-flight automation run (event execution or test run) \u2014 nothing further is sent, and it can never be resumed",
+  sdkMethod: "automations.runs.cancel",
+  route: {
+    method: "POST",
+    path: "/v1/automations/runs/{automationRunId}/cancel"
+  },
+  commandClass: "destructive",
+  args: [
+    {
+      name: "automationRunId",
+      summary: "Run id to cancel (from `automations runs list`, a test start, or a fire response)",
+      isRequired: true
+    }
+  ],
+  flags: [
+    { flag: "--reason <text>", summary: "Operator note stored on the run" },
+    IDEMPOTENCY_FLAG
+  ],
+  examples: [
+    'brew-cli automations runs cancel run_9f2kX --reason "wrong audience" --yes'
+  ],
+  confirmSummary: ({ args }) => `Cancel automation run ${args.automationRunId ?? ""}. Nothing further is sent; emails already delivered are not recalled, and a canceled run can never be resumed.`,
+  run: async ({ ctx, args, flags }) => {
+    const reason = flagString(flags.reason);
+    const options = {
+      ...requestOptions(flags),
+      ...reason === void 0 ? {} : { reason }
+    };
+    return {
+      data: await ctx.client().automations.runs.cancel(
+        args.automationRunId ?? "",
+        Object.keys(options).length === 0 ? void 0 : options
+      )
+    };
+  }
+});
+
+// src/commands/automations/runs/get.ts
+var automationsRunsGetCommand = defineCommand({
+  path: ["automations", "runs", "get"],
+  summary: "Fetch one automation run by id \u2014 the bare row",
+  sdkMethod: "automations.runs.get",
+  route: { method: "GET", path: "/v1/automations/runs/{automationRunId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "automationRunId",
+      summary: "Run id (from `automations runs list`, a test start, or a fire)",
+      isRequired: true
+    }
+  ],
+  flags: [
+    {
+      flag: "--include <tokens>",
+      summary: "Expansions: logs (newest 100 per-node execution logs)"
+    }
+  ],
+  examples: [
+    "brew-cli automations runs get run_9f2kX",
+    "brew-cli automations runs get run_9f2kX --include logs"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const include = flagString(flags.include);
+    return {
+      data: await ctx.client().automations.runs.get(
+        args.automationRunId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
+  }
+});
+
 // src/commands/automations/runs/list.ts
 var automationsRunsListCommand = defineCommand({
   path: ["automations", "runs", "list"],
-  summary: "List automation runs (live + test history)",
+  summary: "List automation runs (live + test history); one run is `automations runs get`",
   sdkMethod: "automations.runs.list",
   route: { method: "GET", path: "/v1/automations/runs" },
   commandClass: "read",
   flags: [
-    {
-      flag: "--run <automationRunId>",
-      summary: "Fetch one run (single-row page)"
-    },
-    {
-      flag: "--include <tokens>",
-      summary: "Comma-separated expansions: logs"
-    },
     { flag: "--automation <automationId>", summary: "Filter by automation" },
     {
       flag: "--trigger <triggerEventId>",
@@ -1982,12 +2479,23 @@ var automationsRunsListCommand = defineCommand({
       flag: "--trigger-instance <triggerInstanceId>",
       summary: "Filter by fired trigger instance"
     },
-    { flag: "--recipient <email>", summary: "Filter by recipient email" },
     {
       flag: "--status <status>",
-      summary: "pending | running | completed | failed | cancelled"
+      summary: "queued | running | completed | failed | canceled"
     },
     { flag: "--mode <mode>", summary: "live | test" },
+    {
+      flag: "--recipient <email>",
+      summary: "Only runs for this recipient (case-insensitive match on the run row's recipientEmail)"
+    },
+    {
+      flag: "--run <automationRunId>",
+      summary: "0.6 shim: read ONE run as a single-row page (`automations runs get` is the real read)"
+    },
+    {
+      flag: "--include <tokens>",
+      summary: "With --run only: detail includes (`logs`)"
+    },
     { flag: "--since <datetime>", summary: "Runs started at/after (ISO-8601)" },
     {
       flag: "--until <datetime>",
@@ -2000,13 +2508,24 @@ var automationsRunsListCommand = defineCommand({
   ],
   examples: [
     "brew-cli automations runs list --automation am_123 --status failed",
-    "brew-cli automations runs list --run arun_123 --include logs"
+    "brew-cli automations runs list --trigger-instance tin_2f1c9d8a"
   ],
   run: async ({ ctx, flags }) => {
+    const runs = ctx.client().automations.runs;
     const base = await readJsonFlag(ctx, flags.input, "--input");
+    const runId = flagString(flags.run) ?? inputField(base, "automationRunId");
+    const include = flagString(flags.include) ?? inputField(base, "include");
+    if (runId !== void 0) {
+      const row = await runs.get(
+        runId,
+        include === void 0 ? void 0 : { include }
+      );
+      return { data: singleRowPage(row), human: renderRuns([row]) };
+    }
+    if (include !== void 0) {
+      throw includeRidesDetailRead("automations runs get", "--run");
+    }
     const input = mergeInput(base, {
-      automationRunId: flagString(flags.run),
-      include: flagString(flags.include),
       automationId: flagString(flags.automation),
       triggerEventId: flagString(flags.trigger),
       triggerInstanceId: flagString(flags.triggerInstance),
@@ -2018,7 +2537,6 @@ var automationsRunsListCommand = defineCommand({
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
-    const runs = ctx.client().automations.runs;
     if (flags.all === true) {
       const rows = await collectAll(
         ctx,
@@ -2083,6 +2601,29 @@ var automationsTestCommand = defineCommand({
   }
 });
 
+// src/commands/automations/trigger-instances/get.ts
+var automationsTriggerInstancesGetCommand = defineCommand({
+  path: ["automations", "trigger-instances", "get"],
+  summary: "Fetch one fired-trigger instance by id \u2014 the bare row, with its lifecycle `state` and the runs it started",
+  sdkMethod: "automations.triggerInstances.get",
+  route: {
+    method: "GET",
+    path: "/v1/automations/trigger-instances/{triggerInstanceId}"
+  },
+  commandClass: "read",
+  args: [
+    {
+      name: "triggerInstanceId",
+      summary: "Instance id returned by a fire, or by the instances list",
+      isRequired: true
+    }
+  ],
+  examples: ["brew-cli automations trigger-instances get tin_2f1c9d8a"],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().automations.triggerInstances.get(args.triggerInstanceId ?? "")
+  })
+});
+
 // src/commands/automations/triggers/contract.ts
 var FORMAT_FLAG = {
   flag: "--format <format>",
@@ -2355,17 +2896,52 @@ var automationsTriggersFireCommand = defineCommand({
   }
 });
 
+// src/commands/automations/triggers/get.ts
+var automationsTriggersGetCommand = defineCommand({
+  path: ["automations", "triggers", "get"],
+  summary: "Fetch one trigger by id \u2014 the bare row with its payload schema",
+  sdkMethod: "automations.triggers.get",
+  route: { method: "GET", path: "/v1/automations/triggers/{triggerEventId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "triggerEventId",
+      summary: "Trigger id (tri_\u2026, or an integration composite id)",
+      isRequired: true
+    }
+  ],
+  flags: [
+    {
+      flag: "--include <tokens>",
+      summary: "Expansions: skill (a SKILL.md-shaped wiring brief)"
+    }
+  ],
+  examples: [
+    "brew-cli automations triggers get tri_signup",
+    "brew-cli automations triggers get tri_signup --include skill"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const include = flagString(flags.include);
+    return {
+      data: await ctx.client().automations.triggers.get(
+        args.triggerEventId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
+  }
+});
+
 // src/commands/automations/triggers/list.ts
 var automationsTriggersListCommand = defineCommand({
   path: ["automations", "triggers", "list"],
-  summary: "List trigger events (their payload schemas drive fires)",
+  summary: "List trigger events (their payload schemas drive fires); one trigger is `automations triggers get`",
   sdkMethod: "automations.triggers.list",
   route: { method: "GET", path: "/v1/automations/triggers" },
   commandClass: "read",
   flags: [
     {
       flag: "--trigger <triggerEventId>",
-      summary: "Fetch one trigger event (single-row page)"
+      summary: "0.6 shim: read ONE trigger as a single-row page (`automations triggers get` is the real read)"
     },
     LIMIT_FLAG,
     CURSOR_FLAG,
@@ -2374,16 +2950,20 @@ var automationsTriggersListCommand = defineCommand({
   ],
   examples: [
     "brew-cli automations triggers list",
-    "brew-cli automations triggers list --trigger tev_123"
+    "brew-cli automations triggers list --all --json"
   ],
   run: async ({ ctx, flags }) => {
+    const triggers = ctx.client().automations.triggers;
     const base = await readJsonFlag(ctx, flags.input, "--input");
+    const triggerEventId = flagString(flags.trigger) ?? inputField(base, "triggerEventId");
+    if (triggerEventId !== void 0) {
+      const row = await triggers.get(triggerEventId);
+      return { data: singleRowPage(row), human: renderTriggers([row]) };
+    }
     const input = mergeInput(base, {
-      triggerEventId: flagString(flags.trigger),
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
-    const triggers = ctx.client().automations.triggers;
     if (flags.all === true) {
       const rows = await collectAll(
         ctx,
@@ -2418,10 +2998,10 @@ function renderTriggers(rows) {
 var automationsTriggersReadyCommand = defineCommand({
   path: ["automations", "triggers", "ready"],
   summary: "Preflight a trigger without firing: key + scope + permissions pass/fail, the payload contract, and what a fire would start",
-  sdkMethod: "automations.triggers.ready",
+  sdkMethod: "automations.triggers.readiness",
   route: {
     method: "GET",
-    path: "/v1/automations/triggers/{triggerEventId}/fire"
+    path: "/v1/automations/triggers/{triggerEventId}/readiness"
   },
   commandClass: "read",
   args: [
@@ -2432,17 +3012,13 @@ var automationsTriggersReadyCommand = defineCommand({
     }
   ],
   examples: ["brew-cli automations triggers ready tri_signup"],
-  // 200 `status: "ready"` means the exact credential in use can fire this
-  // trigger; `details.counts.automations: 0` means fires are accepted and
-  // logged but start no runs until a wired automation is published.
-  run: async ({ ctx, args }) => {
-    const result = await ctx.client().automations.triggers.ready(
-      asSdkInput({
-        triggerEventId: args.triggerEventId ?? ""
-      })
-    );
-    return { data: result };
-  }
+  // 200 `ready: true` means the exact credential in use can fire this
+  // trigger. A `NO_PUBLISHED_AUTOMATION` blocker with `ready: false` means
+  // fires are accepted and logged but start no runs until a wired
+  // automation is published — still a 200, because a probe has to say why.
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().automations.triggers.readiness(args.triggerEventId ?? "")
+  })
 });
 
 // src/commands/automations/triggers/update.ts
@@ -2581,21 +3157,37 @@ var brandGetCommand = defineCommand({
 });
 
 // src/commands/brand/get-images.ts
+var RETIRED_FILTERS = {
+  type: "--type (type) was retired by the API: use --kind logo|brand|generated.",
+  aspectRatio: "--aspect-ratio (aspectRatio) was retired by the API: every image carries its width and height."
+};
 var brandGetImagesCommand = defineCommand({
   path: ["brand", "get-images"],
-  summary: "Browse or semantically search the brand's image library",
-  sdkMethod: "brand.getImages",
+  summary: "Browse or semantically search the brand's assets (logos, brand images, images made with Brew)",
+  sdkMethod: null,
+  isRawTransport: true,
   route: { method: "GET", path: "/v1/brand/images" },
   commandClass: "read",
   flags: [
     {
       flag: "--query <text>",
-      summary: "Semantic search over image descriptions"
+      summary: "Semantic search over what the images show (1 credit per new search; logos are not searchable)"
+    },
+    {
+      flag: "--kind <kind>",
+      summary: "logo, brand (from the site or uploaded) or generated"
+    },
+    {
+      flag: "--sort <order>",
+      summary: "Browse order: newest (default) or oldest; ignored by --query"
+    },
+    {
+      flag: "--type <type>",
+      summary: "Retired by the API: use --kind"
     },
-    { flag: "--type <type>", summary: "Filter by image category" },
     {
       flag: "--aspect-ratio <ratio>",
-      summary: "Filter by aspect ratio (e.g. 16:9)"
+      summary: "Retired by the API: rows carry width and height instead of a shape filter"
     },
     LIMIT_FLAG,
     CURSOR_FLAG,
@@ -2604,48 +3196,68 @@ var brandGetImagesCommand = defineCommand({
   ],
   examples: [
     "brew-cli brand get-images",
-    'brew-cli brand get-images --query "team photo" --aspect-ratio 16:9'
+    "brew-cli brand get-images --kind generated --sort oldest --all",
+    'brew-cli brand get-images --query "team photo" --kind brand'
   ],
   run: async ({ ctx, flags }) => {
     const base = await readJsonFlag(ctx, flags.input, "--input");
     const input = mergeInput(base, {
       q: flagString(flags.query),
-      type: flagString(flags.type),
-      aspectRatio: flagString(flags.aspectRatio),
+      kind: flagString(flags.kind),
+      sort: flagString(flags.sort),
       limit: flagInt(flags.limit, "--limit"),
-      cursor: flagString(flags.cursor)
+      cursor: flagString(flags.cursor),
+      type: flagString(flags.type),
+      aspectRatio: flagString(flags.aspectRatio)
+    });
+    for (const [key, message] of Object.entries(RETIRED_FILTERS)) {
+      if (input[key] !== void 0) {
+        throw new CliUsageError(message);
+      }
+    }
+    const page = (cursor) => rawRequest(ctx, {
+      method: "GET",
+      path: "/v1/brand/images",
+      query: toQuery(cursor === void 0 ? input : { ...input, cursor })
     });
-    const brand = ctx.client().brand;
     if (flags.all === true) {
-      const rows = await collectAll(
-        ctx,
-        (cursor) => brand.getImages(
-          asSdkInput({
-            ...input,
-            ...cursor === void 0 ? {} : { cursor }
-          })
-        )
-      );
+      const rows = await collectAll(ctx, page);
       return {
         data: { data: rows, pagination: { cursor: null, hasMore: false } },
-        human: renderImages(rows)
+        human: renderAssets(rows)
       };
     }
-    const result = await brand.getImages(
-      asSdkInput(input)
-    );
-    return { data: result, human: renderImages(result.data) };
+    const result = await page(void 0);
+    return { data: result, human: renderAssets(result.data) };
   }
 });
-function renderImages(rows) {
-  if (rows.length === 0) {
-    return "No brand images found.";
+function toQuery(input) {
+  const query = {};
+  for (const [key, value] of Object.entries(input)) {
+    query[key] = value === void 0 || value === null ? void 0 : String(value);
   }
-  return renderTable(rows, [
-    { key: "url", header: "URL" },
-    { key: "category", header: "CATEGORY" },
-    { key: "aspectRatio", header: "ASPECT" }
-  ]);
+  return query;
+}
+function renderAssets(rows) {
+  if (rows.length === 0) {
+    return "No brand assets found.";
+  }
+  return renderTable(
+    rows.map((row) => ({
+      assetId: row.assetId,
+      kind: row.kind,
+      url: row.url,
+      size: row.width !== void 0 && row.height !== void 0 ? `${row.width}x${row.height}` : "",
+      added: row.addedAt ?? ""
+    })),
+    [
+      { key: "assetId", header: "ASSET ID" },
+      { key: "kind", header: "KIND" },
+      { key: "url", header: "URL" },
+      { key: "size", header: "SIZE" },
+      { key: "added", header: "ADDED" }
+    ]
+  );
 }
 
 // src/commands/brand/update.ts
@@ -2747,33 +3359,66 @@ var brandsListCommand = defineCommand({
   sdkMethod: "brands.list",
   route: { method: "GET", path: "/v1/brands" },
   commandClass: "read",
-  examples: ["brew-cli brands list --json"],
-  run: async ({ ctx }) => ({
-    data: await ctx.client().brands.list()
-  })
-});
-
-// src/commands/chats/get.ts
-var chatsGetCommand = defineCommand({
-  path: ["chats", "get"],
-  summary: "Brand-scoped digest of a Brew chat (artifacts + transcript tail)",
-  sdkMethod: "chats.get",
-  route: { method: "GET", path: "/v1/chats/{chatId}" },
-  commandClass: "read",
-  args: [
+  flags: [
     {
-      name: "chatId",
-      summary: "Brew chat id (from the chat URL / the app)",
-      isRequired: true
-    }
+      flag: "--status <status>",
+      summary: "Only brands in one lifecycle state: extracting | completed | failed | deleting"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG
   ],
-  examples: ["brew-cli chats get Hk2mZ8t9QbY3sW1vR0pLd"],
-  run: async ({ ctx, args }) => ({
-    data: await ctx.client().chats.get(args.chatId ?? "")
-  })
-});
-
-// src/commands/config.ts
+  examples: [
+    "brew-cli brands list --json",
+    "brew-cli brands list --status completed",
+    "brew-cli brands list --all --json"
+  ],
+  run: async ({ ctx, flags }) => {
+    const input = {
+      status: flagString(flags.status),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    };
+    const brands = ctx.client().brands;
+    if (flags.all === true) {
+      const rows = await collectAll(
+        ctx,
+        (cursor) => brands.list(
+          asSdkInput({
+            ...input,
+            ...cursor === void 0 ? {} : { cursor }
+          })
+        )
+      );
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } }
+      };
+    }
+    return { data: await brands.list(asSdkInput(input)) };
+  }
+});
+
+// src/commands/chats/get.ts
+var chatsGetCommand = defineCommand({
+  path: ["chats", "get"],
+  summary: "Brand-scoped digest of a Brew chat (artifacts + transcript tail)",
+  sdkMethod: "chats.get",
+  route: { method: "GET", path: "/v1/chats/{chatId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "chatId",
+      summary: "Brew chat id (from the chat URL / the app)",
+      isRequired: true
+    }
+  ],
+  examples: ["brew-cli chats get Hk2mZ8t9QbY3sW1vR0pLd"],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().chats.get(args.chatId ?? "")
+  })
+});
+
+// src/commands/config.ts
 var SETTABLE_KEYS = ["brandId", "apiUrl"];
 var configListCommand = defineCommand({
   path: ["config", "list"],
@@ -2962,77 +3607,161 @@ function inlineEmailCount(input) {
 // src/commands/contacts/get.ts
 var contactsGetCommand = defineCommand({
   path: ["contacts", "get"],
-  summary: "Fetch one contact by email",
-  sdkMethod: null,
-  derivedFrom: "contacts.search",
-  route: { method: "POST", path: "/v1/contacts/search" },
+  summary: "Fetch one contact by email \u2014 the bare row",
+  sdkMethod: "contacts.get",
+  route: { method: "GET", path: "/v1/contacts/{email}" },
   commandClass: "read",
   args: [
     {
       name: "email",
-      summary: "Email address of the contact",
+      summary: "Email address of the contact (the contact primary key)",
       isRequired: true
     }
   ],
   examples: ["brew-cli contacts get jane@example.com"],
-  run: async ({ ctx, args }) => {
-    const email = args.email ?? "";
-    const result = await ctx.client().contacts.search({
-      filters: [{ field: "email", operator: "equals", value: email }],
-      limit: 1
-    });
-    const contact = result.data[0];
-    if (contact === void 0) {
-      throw new CliApiError({
-        status: 404,
-        code: "CONTACT_NOT_FOUND",
-        type: "not_found",
-        message: `No contact found for ${email}`,
-        suggestion: "Check the address, or create the contact with `brew-cli contacts upsert`."
-      });
-    }
-    return { data: contact };
-  }
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().contacts.get(args.email ?? "")
+  })
 });
 
 // src/commands/contacts/import-csv.ts
 var contactsImportCsvCommand = defineCommand({
   path: ["contacts", "import-csv"],
-  summary: "Bulk-import contacts from a CSV file or stdin",
+  summary: "Bulk-import contacts from a CSV file or stdin (free; --validate costs 2 credits per address)",
   sdkMethod: "contacts.importCsv",
   route: { method: "POST", path: "/v1/contacts/import-csv" },
   commandClass: "write",
   flags: [
-    { flag: "--file <path>", summary: "CSV file to import, or - for stdin" },
+    {
+      flag: "--file <path>",
+      summary: "CSV file to import, or - for stdin (or csv in --input)"
+    },
     {
       flag: "--mapping <pairs...>",
       summary: "Column mapping csvColumn=fieldName, repeatable"
     },
+    {
+      flag: "--date-order <order>",
+      summary: "month_first or day_first: how to read dates like 03/04/2026 (a day over 12 in the column wins; default month-first, with a DATE_ORDER_ASSUMED warning)"
+    },
+    {
+      flag: "--validate",
+      summary: "Deliverability-check every imported address (2 credits per address)"
+    },
+    {
+      flag: "--consent-source <source>",
+      summary: "Stamp a marketing consent record on every row: api, form or import (sets the source of a record given in --input)"
+    },
+    INPUT_FLAG,
     IDEMPOTENCY_FLAG
   ],
   examples: [
     "brew-cli contacts import-csv --file contacts.csv",
-    "cat contacts.csv | brew-cli contacts import-csv --file - --mapping Email=email"
+    "cat contacts.csv | brew-cli contacts import-csv --file - --mapping Email=email",
+    "brew-cli contacts import-csv --file eu-signups.csv --date-order day_first --consent-source import"
   ],
   run: async ({ ctx, flags }) => {
-    const csv = await readTextFlag(ctx, flags.file, "--file");
-    if (csv === void 0 || csv.trim() === "") {
+    if (flags.input === "-" && flags.file === "-") {
+      throw new CliUsageError("Only one of --input and --file can read stdin.");
+    }
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const consentSource = flagString(flags.consentSource);
+    const input = mergeInput(base, {
+      csv: await readTextFlag(ctx, flags.file, "--file"),
+      mapping: parseKeyValues(flags.mapping, "--mapping"),
+      dateOrder: flagString(flags.dateOrder),
+      validate: flags.validate === true ? true : void 0
+    });
+    if (typeof input.csv !== "string" || input.csv.trim() === "") {
       throw new CliUsageError(
-        "--file is required (a CSV path, or - for stdin)."
+        "Pass the CSV with --file (a path, or - for stdin) or as csv in --input."
       );
     }
-    const mapping = parseKeyValues(flags.mapping, "--mapping");
+    if (consentSource !== void 0) {
+      const record = input.consent;
+      input.consent = {
+        ...typeof record === "object" && record !== null ? record : {},
+        source: consentSource
+      };
+    }
     const result = await ctx.client().contacts.importCsv(
-      asSdkInput({
-        csv,
-        ...mapping === void 0 ? {} : { mapping }
-      }),
+      asSdkInput(input),
       requestOptions(flags)
     );
     return { data: result };
   }
 });
 
+// src/commands/contacts/list.ts
+var contactsListCommand = defineCommand({
+  path: ["contacts", "list"],
+  summary: "List contacts, newest first \u2014 free-text search and one audience; typed clauses are `contacts search`",
+  sdkMethod: "contacts.list",
+  route: { method: "GET", path: "/v1/contacts" },
+  commandClass: "read",
+  flags: [
+    { flag: "--search <text>", summary: "Free-text search" },
+    {
+      flag: "--audience <audienceId>",
+      summary: "Only members of this saved audience"
+    },
+    {
+      flag: "--sort <field>",
+      summary: "Any core column or custom field (default createdAt)"
+    },
+    { flag: "--order <order>", summary: "Sort order: asc | desc" },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
+  ],
+  examples: [
+    "brew-cli contacts list --limit 20",
+    "brew-cli contacts list --audience aud_3k9sQ --all --json",
+    "brew-cli contacts list --search acme --sort email --order asc"
+  ],
+  run: async ({ ctx, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const input = mergeInput(base, {
+      search: flagString(flags.search),
+      audienceId: flagString(flags.audience),
+      sort: flagString(flags.sort),
+      order: flagString(flags.order),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    });
+    const contacts = ctx.client().contacts;
+    if (flags.all === true) {
+      const rows = await collectAll(
+        ctx,
+        (cursor) => contacts.list(
+          asSdkInput({
+            ...input,
+            ...cursor === void 0 ? {} : { cursor }
+          })
+        )
+      );
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } },
+        human: renderContacts(rows)
+      };
+    }
+    const result = await contacts.list(asSdkInput(input));
+    return { data: result, human: renderContacts(result.data) };
+  }
+});
+function renderContacts(rows) {
+  if (rows.length === 0) {
+    return "No contacts found.";
+  }
+  return renderTable(rows, [
+    { key: "email", header: "EMAIL" },
+    { key: "firstName", header: "FIRST" },
+    { key: "lastName", header: "LAST" },
+    { key: "subscribed", header: "SUBSCRIBED" }
+  ]);
+}
+
 // src/commands/contacts/search.ts
 var contactsSearchCommand = defineCommand({
   path: ["contacts", "search"],
@@ -3085,14 +3814,14 @@ var contactsSearchCommand = defineCommand({
       );
       return {
         data: { data: rows, pagination: { cursor: null, hasMore: false } },
-        human: renderContacts(rows)
+        human: renderContacts2(rows)
       };
     }
     const result = await contacts.search(asSdkInput(input));
-    return { data: result, human: renderContacts(result.data) };
+    return { data: result, human: renderContacts2(result.data) };
   }
 });
-function renderContacts(rows) {
+function renderContacts2(rows) {
   if (rows.length === 0) {
     return "No contacts matched.";
   }
@@ -3560,14 +4289,17 @@ var contractsInferCommand = defineCommand({
   examples: [
     `brew-cli contracts infer --input '{"email":"jane@example.com","order":{"total":9.5}}'`
   ],
-  // Accepts either the bare example object or `{ example: {...} }`.
-  // Un-inferable spots (nulls, empty arrays) come back under `issues`.
+  // Accepts either the bare example object or `{ example: {...} }`; only the
+  // envelope carries `subjectKind` (a bare example may have its own field of
+  // that name). Un-inferable spots (nulls, empty arrays) come back under
+  // `issues`.
   run: async ({ ctx, flags }) => {
     const input = mergeInput(
       await readJsonFlag(ctx, flags.input, "--input"),
       {}
     );
-    const example = input.example ?? input;
+    const isEnvelope = input.example !== void 0;
+    const example = isEnvelope ? input.example : input;
     if (typeof example !== "object" || example === null || Array.isArray(example) || Object.keys(example).length === 0) {
       throw new CliUsageError(
         "--input with a non-empty example object is required (the JSON your system sends)."
@@ -3576,7 +4308,10 @@ var contractsInferCommand = defineCommand({
     const body = await rawRequest(ctx, {
       method: "POST",
       path: "/v1/payload-contracts/infer",
-      body: { example }
+      body: {
+        example,
+        ...isEnvelope && input.subjectKind !== void 0 ? { subjectKind: input.subjectKind } : {}
+      }
     });
     return { data: body };
   }
@@ -3628,6 +4363,10 @@ var SDK_SKIP_LIST = [
     sdkPath: "automations.triggers.validatePayload",
     reason: "covered by `automations triggers contract validate` (raw route, bound pre-SDK-v9)"
   },
+  {
+    sdkPath: "brand.getImages",
+    reason: "covered by `brand get-images` (raw route: SDK 10 cannot send `kind` or `sort`, brew-v2#1713; bind SDK 11.2)"
+  },
   {
     sdkPath: "payloadContracts.infer",
     reason: "covered by `contracts infer` (raw route, bound pre-SDK-v9)"
@@ -3641,12 +4380,12 @@ var SDK_SKIP_LIST = [
     reason: "auto-pager covered by `analytics events --all`"
   },
   {
-    sdkPath: "analytics.sends.listAll",
-    reason: "auto-pager covered by `analytics sends list --all`"
+    sdkPath: "sends.listAll",
+    reason: "auto-pager covered by `sends list --all`"
   },
   {
-    sdkPath: "analytics.triggerInstances.listAll",
-    reason: "auto-pager covered by `analytics trigger-instances list --all`"
+    sdkPath: "automations.triggerInstances.listAll",
+    reason: "auto-pager covered by `automations trigger-instances list --all`"
   },
   {
     sdkPath: "brand.update",
@@ -3722,7 +4461,7 @@ function buildManifest() {
 
 // src/commands/docs.ts
 var DOCS_POINTERS = {
-  documentation: "https://docs.getbrew.io",
+  documentation: "https://docs.brew.new",
   openapiSpec: "https://brew.new/openapi/public-api-v1.yaml",
   agentGuide: "https://brew.new/api/v1/llms.txt",
   apiCatalog: "https://brew.new/api/v1/help",
@@ -3913,28 +4652,15 @@ var domainsDeleteCommand = defineCommand({
 // src/commands/domains/get.ts
 var domainsGetCommand = defineCommand({
   path: ["domains", "get"],
-  summary: "Fetch one sending domain by id",
-  sdkMethod: null,
-  derivedFrom: "domains.list",
-  route: { method: "GET", path: "/v1/domains" },
+  summary: "Fetch one sending domain by id \u2014 the bare row",
+  sdkMethod: "domains.get",
+  route: { method: "GET", path: "/v1/domains/{domainId}" },
   commandClass: "read",
   args: [{ name: "domainId", summary: "Domain id to fetch", isRequired: true }],
   examples: ["brew-cli domains get dom_3k9sQ"],
-  run: async ({ ctx, args }) => {
-    const domainId = args.domainId ?? "";
-    const result = await ctx.client().domains.list({ domainId });
-    const domain = result.data[0];
-    if (domain === void 0) {
-      throw new CliApiError({
-        status: 404,
-        code: "DOMAIN_NOT_FOUND",
-        type: "not_found",
-        message: `No domain found for ${domainId}`,
-        suggestion: "List domains with `brew-cli domains list`."
-      });
-    }
-    return { data: domain };
-  }
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().domains.get(args.domainId ?? "")
+  })
 });
 
 // src/commands/domains/health.ts
@@ -4015,109 +4741,297 @@ function renderDomains(rows) {
   ]);
 }
 
-// src/commands/domains/update.ts
-var domainsUpdateCommand = defineCommand({
-  path: ["domains", "update"],
-  summary: "Update default sender settings for a domain",
-  sdkMethod: "domains.updateSettings",
-  route: { method: "PATCH", path: "/v1/domains/{domainId}" },
+// src/commands/domains/unsubscribes/add.ts
+var domainsUnsubscribesAddCommand = defineCommand({
+  path: ["domains", "unsubscribes", "add"],
+  summary: "Add addresses to a marketing domain's unsubscribe list (that domain only)",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: { method: "POST", path: "/v1/domains/{domainId}/unsubscribes" },
   commandClass: "write",
   args: [
-    { name: "domainId", summary: "Domain id to update", isRequired: true }
+    { name: "domainId", summary: "Marketing domain id", isRequired: true }
   ],
   flags: [
     {
-      flag: "--default-sender-name <name>",
-      summary: "Default From display name"
-    },
-    {
-      flag: "--default-from-email <email>",
-      summary: "Default From address on this domain"
-    },
-    {
-      flag: "--default-reply-to-email <email>",
-      summary: "Default Reply-To address"
+      flag: "--email <addresses...>",
+      summary: "Address to suppress, repeatable (up to 1,000)"
     },
-    INPUT_FLAG
+    IDEMPOTENCY_FLAG
   ],
   examples: [
-    'brew-cli domains update dom_8s1Kj --default-sender-name "Brew Coffee"'
+    "brew-cli domains unsubscribes add dom_123 --email ada@example.com --email bo@example.com"
   ],
   run: async ({ ctx, args, flags }) => {
-    const base = await readJsonFlag(ctx, flags.input, "--input");
-    const input = mergeInput(base, {
-      defaultSenderName: flagString(flags.defaultSenderName),
-      defaultFromEmail: flagString(flags.defaultFromEmail),
-      defaultReplyToEmail: flagString(flags.defaultReplyToEmail)
-    });
-    if (Object.keys(input).length === 0) {
-      throw new CliUsageError("Nothing to update \u2014 pass flags or --input.");
+    const emails = toStringArray(flags.email);
+    if (emails === void 0) {
+      throw new CliUsageError("Pass at least one --email.");
     }
-    const result = await ctx.client().domains.updateSettings(
-      asSdkInput({
-        ...input,
-        domainId: args.domainId ?? ""
-      })
-    );
-    return { data: result };
+    const body = await rawRequest(ctx, {
+      method: "POST",
+      path: `/v1/domains/${encodeURIComponent(args.domainId ?? "")}/unsubscribes`,
+      body: { emails },
+      idempotencyKey: flagString(flags.idempotencyKey)
+    });
+    return { data: body };
   }
 });
 
-// src/commands/domains/verify.ts
-var domainsVerifyCommand = defineCommand({
-  path: ["domains", "verify"],
-  summary: "Re-check DNS records and refresh domain verification",
-  sdkMethod: "domains.verify",
-  route: { method: "POST", path: "/v1/domains/{domainId}/verify" },
-  commandClass: "write",
+// src/commands/domains/unsubscribes/export.ts
+var domainsUnsubscribesExportCommand = defineCommand({
+  path: ["domains", "unsubscribes", "export"],
+  summary: "A domain's unsubscribe list as CSV (truncated when capped)",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: {
+    method: "GET",
+    path: "/v1/domains/{domainId}/unsubscribes/export"
+  },
+  commandClass: "read",
   args: [
-    { name: "domainId", summary: "Domain id to verify", isRequired: true }
+    { name: "domainId", summary: "Marketing domain id", isRequired: true }
   ],
-  examples: ["brew-cli domains verify dom_8s1Kj"],
-  run: async ({ ctx, args }) => ({
-    data: await ctx.client().domains.verify({ domainId: args.domainId ?? "" })
-  })
+  flags: [
+    {
+      flag: "--scope <scope>",
+      summary: "any (default), domain or all"
+    }
+  ],
+  examples: [
+    "brew-cli domains unsubscribes export dom_123 > optouts.csv",
+    "brew-cli domains unsubscribes export dom_123 --scope all --json"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const body = await rawRequest(ctx, {
+      method: "GET",
+      path: `/v1/domains/${encodeURIComponent(args.domainId ?? "")}/unsubscribes/export`,
+      query: { scope: flagString(flags.scope) }
+    });
+    return { data: body, human: body.csv };
+  }
 });
-var SENDING_PURPOSES = /* @__PURE__ */ new Set(["marketing", "transactional"]);
-function optionalText(value) {
-  return typeof value === "string" ? value : void 0;
-}
-var emailsAuditCommand = defineCommand({
-  path: ["emails", "audit"],
-  summary: "Audit raw email content for production readiness (5 credits when complete)",
-  sdkMethod: "emails.auditEmail",
-  route: { method: "POST", path: "/v1/emails/audit" },
+
+// src/commands/domains/unsubscribes/import.ts
+var domainsUnsubscribesImportCommand = defineCommand({
+  path: ["domains", "unsubscribes", "import"],
+  summary: "Add every address in a CSV to a domain's unsubscribe list",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: {
+    method: "POST",
+    path: "/v1/domains/{domainId}/unsubscribes/import"
+  },
   commandClass: "write",
-  isCredited: true,
+  args: [
+    { name: "domainId", summary: "Marketing domain id", isRequired: true }
+  ],
   flags: [
+    { flag: "--file <path>", summary: "CSV file, or - for stdin" },
     {
-      flag: "--file <path>",
-      summary: "Email HTML file to audit, or - for stdin"
-    },
-    { flag: "--subject <text>", summary: "Inbox subject line" },
-    {
-      flag: "--preview-text <text>",
-      summary: "Inbox preview text; an explicit empty value stays empty"
-    },
-    {
-      flag: "--sending-purpose <purpose>",
-      summary: "marketing | transactional (default: marketing)"
+      flag: "--column <header>",
+      summary: "The column holding the addresses (by header)"
     },
-    INPUT_FLAG,
     IDEMPOTENCY_FLAG
   ],
   examples: [
-    'brew-cli emails audit --file newsletter.html --subject "August update" --sending-purpose marketing',
-    'cat email.html | brew-cli emails audit --file - --subject "Receipt" --sending-purpose transactional',
-    `brew-cli emails audit --input '{"emailHtml":"<p>Hello</p>","subject":"Hello"}'`
+    "brew-cli domains unsubscribes import dom_123 --file optouts.csv --column Email"
   ],
-  run: async ({ ctx, flags }) => {
-    const base = await readJsonFlag(ctx, flags.input, "--input");
-    const emailHtml = await readTextFlag(ctx, flags.file, "--file");
-    const sendingPurpose = flagString(flags.sendingPurpose);
-    if (sendingPurpose !== void 0 && !SENDING_PURPOSES.has(sendingPurpose)) {
-      throw new CliUsageError(
-        `Unknown --sending-purpose '${sendingPurpose}' (expected marketing | transactional).`
+  run: async ({ ctx, args, flags }) => {
+    const csv = await readTextFlag(ctx, flags.file, "--file");
+    if (csv === void 0 || csv.trim() === "") {
+      throw new CliUsageError(
+        "--file is required (a CSV path, or - for stdin)."
+      );
+    }
+    const column = flagString(flags.column);
+    const body = await rawRequest(ctx, {
+      method: "POST",
+      path: `/v1/domains/${encodeURIComponent(args.domainId ?? "")}/unsubscribes/import`,
+      body: { csv, ...column === void 0 ? {} : { column } },
+      idempotencyKey: flagString(flags.idempotencyKey)
+    });
+    return { data: body };
+  }
+});
+
+// src/commands/domains/unsubscribes/list.ts
+var domainsUnsubscribesListCommand = defineCommand({
+  path: ["domains", "unsubscribes", "list"],
+  summary: "One page of a marketing domain's unsubscribe list, newest first",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: { method: "GET", path: "/v1/domains/{domainId}/unsubscribes" },
+  commandClass: "read",
+  args: [
+    { name: "domainId", summary: "Marketing domain id", isRequired: true }
+  ],
+  flags: [
+    { flag: "--q <text>", summary: "Search by address" },
+    {
+      flag: "--scope <scope>",
+      summary: "any (default), domain (this list only) or all (brand-wide opt-outs)"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG
+  ],
+  examples: [
+    "brew-cli domains unsubscribes list dom_123",
+    "brew-cli domains unsubscribes list dom_123 --scope domain --q ada"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const limit = flagInt(flags.limit, "--limit");
+    const body = await rawRequest(ctx, {
+      method: "GET",
+      path: `/v1/domains/${encodeURIComponent(args.domainId ?? "")}/unsubscribes`,
+      query: {
+        q: flagString(flags.q),
+        scope: flagString(flags.scope),
+        limit: limit === void 0 ? void 0 : String(limit),
+        cursor: flagString(flags.cursor)
+      }
+    });
+    return { data: body, human: renderRows(body.data) };
+  }
+});
+function renderRows(rows) {
+  if (rows.length === 0) {
+    return "No unsubscribes on this list.";
+  }
+  return renderTable(rows, [
+    { key: "email", header: "EMAIL" },
+    { key: "scope", header: "SCOPE" },
+    { key: "unsubscribedAt", header: "UNSUBSCRIBED" }
+  ]);
+}
+
+// src/commands/domains/unsubscribes/remove.ts
+var domainsUnsubscribesRemoveCommand = defineCommand({
+  path: ["domains", "unsubscribes", "remove"],
+  summary: "Take one address off a domain's unsubscribe list (never re-subscribes a brand-wide opt-out)",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: {
+    method: "DELETE",
+    path: "/v1/domains/{domainId}/unsubscribes/{email}"
+  },
+  commandClass: "write",
+  args: [
+    { name: "domainId", summary: "Marketing domain id", isRequired: true },
+    { name: "email", summary: "Address to remove", isRequired: true }
+  ],
+  flags: [],
+  examples: ["brew-cli domains unsubscribes remove dom_123 ada@example.com"],
+  run: async ({ ctx, args }) => ({
+    data: await rawRequest(ctx, {
+      method: "DELETE",
+      path: `/v1/domains/${encodeURIComponent(args.domainId ?? "")}/unsubscribes/${encodeURIComponent(args.email ?? "")}`
+    })
+  })
+});
+
+// src/commands/domains/update.ts
+var domainsUpdateCommand = defineCommand({
+  path: ["domains", "update"],
+  summary: "Update default sender settings for a domain",
+  sdkMethod: "domains.updateSettings",
+  route: { method: "PATCH", path: "/v1/domains/{domainId}" },
+  commandClass: "write",
+  args: [
+    { name: "domainId", summary: "Domain id to update", isRequired: true }
+  ],
+  flags: [
+    {
+      flag: "--default-sender-name <name>",
+      summary: "Default From display name"
+    },
+    {
+      flag: "--default-from-email <email>",
+      summary: "Default From address on this domain"
+    },
+    {
+      flag: "--default-reply-to-email <email>",
+      summary: "Default Reply-To address"
+    },
+    INPUT_FLAG
+  ],
+  examples: [
+    'brew-cli domains update dom_8s1Kj --default-sender-name "Brew Coffee"'
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const input = mergeInput(base, {
+      defaultSenderName: flagString(flags.defaultSenderName),
+      defaultFromEmail: flagString(flags.defaultFromEmail),
+      defaultReplyToEmail: flagString(flags.defaultReplyToEmail)
+    });
+    if (Object.keys(input).length === 0) {
+      throw new CliUsageError("Nothing to update \u2014 pass flags or --input.");
+    }
+    const result = await ctx.client().domains.updateSettings(
+      asSdkInput({
+        ...input,
+        domainId: args.domainId ?? ""
+      })
+    );
+    return { data: result };
+  }
+});
+
+// src/commands/domains/verify.ts
+var domainsVerifyCommand = defineCommand({
+  path: ["domains", "verify"],
+  summary: "Re-check DNS records and refresh domain verification",
+  sdkMethod: "domains.verify",
+  route: { method: "POST", path: "/v1/domains/{domainId}/verify" },
+  commandClass: "write",
+  args: [
+    { name: "domainId", summary: "Domain id to verify", isRequired: true }
+  ],
+  examples: ["brew-cli domains verify dom_8s1Kj"],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().domains.verify({ domainId: args.domainId ?? "" })
+  })
+});
+var SENDING_PURPOSES = /* @__PURE__ */ new Set(["marketing", "transactional"]);
+function optionalText(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var emailsAuditCommand = defineCommand({
+  path: ["emails", "audit"],
+  summary: "Audit raw email content for production readiness (5 credits when complete)",
+  sdkMethod: "emails.auditEmail",
+  route: { method: "POST", path: "/v1/emails/audit" },
+  commandClass: "write",
+  isCredited: true,
+  flags: [
+    {
+      flag: "--file <path>",
+      summary: "Email HTML file to audit, or - for stdin"
+    },
+    { flag: "--subject <text>", summary: "Inbox subject line" },
+    {
+      flag: "--preview-text <text>",
+      summary: "Inbox preview text; an explicit empty value stays empty"
+    },
+    {
+      flag: "--sending-purpose <purpose>",
+      summary: "marketing | transactional (default: marketing)"
+    },
+    INPUT_FLAG,
+    IDEMPOTENCY_FLAG
+  ],
+  examples: [
+    'brew-cli emails audit --file newsletter.html --subject "August update" --sending-purpose marketing',
+    'cat email.html | brew-cli emails audit --file - --subject "Receipt" --sending-purpose transactional',
+    `brew-cli emails audit --input '{"emailHtml":"<p>Hello</p>","subject":"Hello"}'`
+  ],
+  run: async ({ ctx, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const emailHtml = await readTextFlag(ctx, flags.file, "--file");
+    const sendingPurpose = flagString(flags.sendingPurpose);
+    if (sendingPurpose !== void 0 && !SENDING_PURPOSES.has(sendingPurpose)) {
+      throw new CliUsageError(
+        `Unknown --sending-purpose '${sendingPurpose}' (expected marketing | transactional).`
       );
     }
     const input = mergeInput(base, {
@@ -4160,19 +5074,41 @@ var emailsCloneCommand = defineCommand({
       flag: "--email-version-id <id>",
       summary: "Exact source version to clone (default: latest)"
     },
+    {
+      flag: "--title <title>",
+      summary: "Name for the clone (default: Copy of <source title>)"
+    },
+    {
+      flag: "--group-id <groupId>",
+      summary: "File the clone under an existing group (grp_\u2026), or ungrouped"
+    },
+    {
+      flag: "--group-name <name>",
+      summary: "File the clone under a group found (or created) by this name; not with --group-id"
+    },
     IDEMPOTENCY_FLAG
   ],
   examples: [
     "brew-cli emails clone eml_2SmZOWV3ZQ7W5x6g3m4p",
-    "brew-cli emails clone eml_2SmZOWV3ZQ7W5x6g3m4p --email-version-id emv_9f2kX"
+    "brew-cli emails clone eml_2SmZOWV3ZQ7W5x6g3m4p --email-version-id emv_9f2kX",
+    'brew-cli emails clone eml_2SmZOWV3ZQ7W5x6g3m4p --title "Fall sale (B)" --group-name "Fall campaign"'
   ],
   run: async ({ ctx, args, flags }) => {
     const emailVersionId = flagString(flags.emailVersionId);
+    const title = flagString(flags.title);
+    const groupId = flagString(flags.groupId);
+    const groupName = flagString(flags.groupName);
+    if (groupId !== void 0 && groupName !== void 0) {
+      throw new CliUsageError("Pass --group-id or --group-name, not both.");
+    }
     return {
       data: await ctx.client().emails.clone(
         asSdkInput({
           emailId: args.emailId ?? "",
-          ...emailVersionId === void 0 ? {} : { emailVersionId }
+          ...emailVersionId === void 0 ? {} : { emailVersionId },
+          ...title === void 0 ? {} : { title },
+          ...groupId === void 0 ? {} : { groupId },
+          ...groupName === void 0 ? {} : { groupName }
         }),
         requestOptions(flags)
       )
@@ -4184,7 +5120,7 @@ var emailsCloneCommand = defineCommand({
 var emailsCreateInboxPlacementTestCommand = defineCommand({
   path: ["emails", "create-inbox-placement-test"],
   summary: "Seed-test where the design lands (inbox vs spam) via a real small send (10 credits)",
-  sdkMethod: "emails.createInboxPlacementTest",
+  sdkMethod: "emails.inboxPlacementTests.create",
   route: { method: "POST", path: "/v1/emails/{emailId}/inbox-placement-tests" },
   commandClass: "write",
   isCredited: true,
@@ -4228,9 +5164,9 @@ var emailsCreateInboxPlacementTestCommand = defineCommand({
     const emailVersionId = flagString(flags.emailVersionId);
     const providers = toStringArray(flags.providers);
     return {
-      // The API answers 202 with a pending test (status: "collecting");
-      // poll `emails get-inbox-placement-results --test-id` for the outcome.
-      data: await ctx.client().emails.createInboxPlacementTest(
+      // The API answers 202 with a pending test (status: "queued"); poll
+      // `emails get-inbox-placement-results --test-id` for the outcome.
+      data: await ctx.client().emails.inboxPlacementTests.create(
         asSdkInput({
           emailId: args.emailId ?? "",
           domainId,
@@ -4261,9 +5197,13 @@ var emailsDeleteCommand = defineCommand({
 });
 
 // src/commands/emails/edit.ts
+var ENVELOPE_FIELDS = ["title", "subjectLine", "groupId"];
+function isText(value) {
+  return typeof value === "string" && value !== "";
+}
 var emailsEditCommand = defineCommand({
   path: ["emails", "edit"],
-  summary: "AI-edit an email design, and/or set its subject line (subject-only is free)",
+  summary: "AI-edit an email design, and/or set its subject line, title or group (free without a prompt)",
   sdkMethod: "emails.edit",
   route: { method: "PATCH", path: "/v1/emails/{emailId}" },
   commandClass: "write",
@@ -4283,30 +5223,54 @@ var emailsEditCommand = defineCommand({
       flag: "--subject-line <text>",
       summary: "The design's default inbox subject line; alone it skips the AI run"
     },
+    {
+      flag: "--title <text>",
+      summary: "Rename the design (its canvas name); alone it skips the AI run"
+    },
+    {
+      flag: "--group-id <groupId>",
+      summary: "Move the design into this existing group; alone it skips the AI run"
+    },
+    {
+      flag: "--ungroup",
+      summary: "Move the design to Ungrouped (groupId: null)"
+    },
     INPUT_FLAG
   ],
   examples: [
     'brew-cli emails edit eml_2SmZOWV3ZQ7W5x6g3m4p --prompt "Tighten the hero copy"',
-    'brew-cli emails edit eml_2SmZOWV3ZQ7W5x6g3m4p --subject-line "Your September roundup"'
+    'brew-cli emails edit eml_2SmZOWV3ZQ7W5x6g3m4p --subject-line "Your September roundup"',
+    'brew-cli emails edit eml_2SmZOWV3ZQ7W5x6g3m4p --title "Fall sale v2" --group-id grp_7Hq2',
+    "brew-cli emails edit eml_2SmZOWV3ZQ7W5x6g3m4p --ungroup"
   ],
   run: async ({ ctx, args, flags }) => {
+    const groupId = flagString(flags.groupId);
+    if (groupId !== void 0 && flags.ungroup === true) {
+      throw new CliUsageError(
+        "--group-id and --ungroup conflict: pick one group move."
+      );
+    }
     const base = await readJsonFlag(ctx, flags.input, "--input");
     const input = mergeInput(base, {
       prompt: flagString(flags.prompt),
       emailVersionId: flagString(flags.emailVersionId),
       contentUrls: toStringArray(flags.contentUrls),
-      subjectLine: flagString(flags.subjectLine)
+      subjectLine: flagString(flags.subjectLine),
+      title: flagString(flags.title),
+      groupId: flags.ungroup === true ? null : groupId
     });
-    const isPromptEdit = typeof input.prompt === "string" && input.prompt !== "";
-    const hasSubjectLine = typeof input.subjectLine === "string" && input.subjectLine !== "";
-    if (!(isPromptEdit || hasSubjectLine)) {
+    const isPromptEdit = isText(input.prompt);
+    const envelope = ENVELOPE_FIELDS.filter(
+      (field) => isText(input[field]) || field === "groupId" && input[field] === null
+    );
+    if (!isPromptEdit && envelope.length === 0) {
       throw new CliUsageError(
-        "--prompt or --subject-line is required (or provide either via --input)."
+        "Pass --prompt, or at least one of --subject-line, --title, --group-id or --ungroup (or those fields via --input)."
       );
     }
     progress(
       ctx,
-      isPromptEdit ? "Editing email\u2026 (typically 30-90s)" : "Setting the subject line\u2026"
+      isPromptEdit ? "Editing email\u2026 (typically 30-90s)" : envelope.length === 1 && envelope[0] === "subjectLine" ? "Setting the subject line\u2026" : "Updating the design (no AI run)\u2026"
     );
     const result = await ctx.client().emails.edit(
       asSdkInput({ ...input, emailId: args.emailId ?? "" }),
@@ -4327,12 +5291,16 @@ var emailsExportCommand = defineCommand({
   flags: [
     {
       flag: "--provider <provider>",
-      summary: "Connected ESP: braze, hubspot, klaviyo, mailchimp, iterable, postmark, onesignal, mailgun, sendgrid"
+      summary: "Connected ESP: braze, brevo, hubspot, klaviyo, mailchimp, mailjet, iterable, postmark, onesignal, mailgun, sendgrid"
     },
     {
       flag: "--template-name <name>",
       summary: "Template name in the ESP (default: the email title)"
     },
+    {
+      flag: "--sender-email <email>",
+      summary: "Brevo or Mailjet: the active sender to use (omit when the account has exactly one)"
+    },
     {
       flag: "--dry-run",
       summary: "Validate design, ownership, and ESP connection without creating a template"
@@ -4347,18 +5315,20 @@ var emailsExportCommand = defineCommand({
     const provider = flagString(flags.provider);
     if (provider === void 0) {
       throw new CliUsageError(
-        "--provider is required: braze, hubspot, klaviyo, mailchimp, iterable, postmark, onesignal, mailgun, or sendgrid."
+        "--provider is required: braze, brevo, hubspot, klaviyo, mailchimp, mailjet, iterable, postmark, onesignal, mailgun, or sendgrid."
       );
     }
     const templateName = flagString(flags.templateName);
+    const senderEmail = flagString(flags.senderEmail);
     return {
       data: await ctx.client().emails.export(
         asSdkInput({
           emailId: args.emailId ?? "",
           provider,
           ...templateName === void 0 ? {} : { templateName },
+          ...senderEmail === void 0 ? {} : { senderEmail },
           // The spec field is snake_case, unlike the rest of the API surface.
-          ...flags.dryRun === true ? { dry_run: true } : {}
+          ...flags.dryRun === true ? { dryRun: true } : {}
         }),
         requestOptions(flags)
       )
@@ -4427,10 +5397,9 @@ var emailsGenerateCommand = defineCommand({
 // src/commands/emails/get.ts
 var emailsGetCommand = defineCommand({
   path: ["emails", "get"],
-  summary: "Fetch one email design by id",
-  sdkMethod: null,
-  derivedFrom: "emails.list",
-  route: { method: "GET", path: "/v1/emails" },
+  summary: "Fetch one email design by id \u2014 the bare row",
+  sdkMethod: "emails.get",
+  route: { method: "GET", path: "/v1/emails/{emailId}" },
   commandClass: "read",
   args: [
     {
@@ -4442,39 +5411,126 @@ var emailsGetCommand = defineCommand({
   flags: [
     {
       flag: "--include <tokens>",
-      summary: "Comma-separated expansions: html,versions"
+      summary: "Comma-separated expansions: html, versions, text, links"
+    },
+    {
+      flag: "--email-version-id <emailVersionId>",
+      summary: "Read this saved version instead of the current head (ids from --include versions)"
+    },
+    {
+      flag: "--run-id <runId>",
+      summary: "Read the version a generate or edit run produced (the runId it returned)"
     }
   ],
   examples: [
     "brew-cli emails get eml_2SmZOWV3ZQ7W5x6g3m4p",
-    "brew-cli emails get eml_2SmZOWV3ZQ7W5x6g3m4p --include html,versions"
+    "brew-cli emails get eml_2SmZOWV3ZQ7W5x6g3m4p --include html,versions",
+    "brew-cli emails get eml_2SmZOWV3ZQ7W5x6g3m4p --include text,links",
+    "brew-cli emails get eml_2SmZOWV3ZQ7W5x6g3m4p --email-version-id emv_2SmZOWV3ZQ7W5x6g3m4p --include html"
   ],
   run: async ({ ctx, args, flags }) => {
     const emailId = args.emailId ?? "";
     const include = flagString(flags.include);
-    const result = await ctx.client().emails.list({
-      emailId,
-      ...include === void 0 ? {} : { include }
+    const emailVersionId = flagString(flags.emailVersionId);
+    const runId = flagString(flags.runId);
+    if (emailVersionId !== void 0 && runId !== void 0) {
+      throw new CliUsageError(
+        "Pass --email-version-id or --run-id, not both: each selects the version to read."
+      );
+    }
+    if (emailVersionId === void 0 && runId === void 0) {
+      return {
+        data: await ctx.client().emails.get(emailId, include === void 0 ? void 0 : { include })
+      };
+    }
+    return {
+      data: await rawRequest(ctx, {
+        method: "GET",
+        path: `/v1/emails/${encodeURIComponent(emailId)}`,
+        query: { include, emailVersionId, runId }
+      })
+    };
+  }
+});
+
+// src/commands/emails/get-audit.ts
+var emailsGetAuditCommand = defineCommand({
+  path: ["emails", "get-audit"],
+  summary: "Read a saved email audit: one page of its findings (free; never reruns the audit)",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: { method: "GET", path: "/v1/emails/audits/{auditId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "auditId",
+      summary: "The auditId `emails audit` returned (reports are kept 7 days)",
+      isRequired: true
+    }
+  ],
+  // Its own page size: a saved audit pages 1-50 findings (default 10), not
+  // the shared list's 1-100.
+  flags: [
+    { flag: "--limit <n>", summary: "Findings per page, 1-50 (default 10)" },
+    CURSOR_FLAG
+  ],
+  examples: [
+    "brew-cli emails get-audit 6f1e2d3c-4b5a-4c7d-8e9f-0a1b2c3d4e5f",
+    "brew-cli emails get-audit 6f1e2d3c-4b5a-4c7d-8e9f-0a1b2c3d4e5f --limit 20"
+  ],
+  // The next page is `--cursor <pagination.cursor>`; `pagination.hasMore`
+  // says whether one exists.
+  run: async ({ ctx, args, flags }) => {
+    const limit = flagInt(flags.limit, "--limit");
+    const body = await rawRequest(ctx, {
+      method: "GET",
+      path: `/v1/emails/audits/${encodeURIComponent(args.auditId ?? "")}`,
+      query: {
+        cursor: flagString(flags.cursor),
+        limit: limit === void 0 ? void 0 : String(limit)
+      }
     });
-    const email = result.data[0];
-    if (email === void 0) {
-      throw new CliApiError({
-        status: 404,
-        code: "EMAIL_NOT_FOUND",
-        type: "not_found",
-        message: `No email design found for ${emailId}`,
-        suggestion: "List designs with `brew-cli emails list`."
-      });
+    return { data: body };
+  }
+});
+
+// src/commands/emails/get-client-preview.ts
+var emailsGetClientPreviewCommand = defineCommand({
+  path: ["emails", "get-client-preview"],
+  summary: "Poll a client-preview rendering job: per-client screenshot links once it settles (free; never re-renders)",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: { method: "GET", path: "/v1/emails/client-previews/{previewId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "previewId",
+      summary: "The previewId `emails preview-clients` returned",
+      isRequired: true
     }
-    return { data: email };
+  ],
+  examples: [
+    "brew-cli emails get-client-preview prv_0b7f3c1e-9a2d-4e8b-b6c5-3d1f2a9e8c47",
+    "brew-cli emails get-client-preview prv_0b7f3c1e-9a2d-4e8b-b6c5-3d1f2a9e8c47 --json | jq '.previews[] | {label, status, imageUrl}'"
+  ],
+  // While `status` is `queued` or `running`, poll again after
+  // `nextPollAfterMs`. It settles as `completed`, `partially_completed` or
+  // `failed`; each client then carries its `imageUrl`, or a `reason` and
+  // whether it is `retryable`.
+  run: async ({ ctx, args }) => {
+    const body = await rawRequest(ctx, {
+      method: "GET",
+      path: `/v1/emails/client-previews/${encodeURIComponent(args.previewId ?? "")}`
+    });
+    return { data: body };
   }
 });
 
 // src/commands/emails/get-inbox-placement-results.ts
 var emailsGetInboxPlacementResultsCommand = defineCommand({
   path: ["emails", "get-inbox-placement-results"],
-  summary: "Inbox placement results: one test with --test-id, else the recent tests",
-  sdkMethod: "emails.getInboxPlacementResults",
+  summary: "Inbox placement results: the recent tests, or one test with --test-id",
+  sdkMethod: "emails.inboxPlacementTests.list",
   route: { method: "GET", path: "/v1/emails/{emailId}/inbox-placement-tests" },
   commandClass: "read",
   args: [
@@ -4486,22 +5542,38 @@ var emailsGetInboxPlacementResultsCommand = defineCommand({
   ],
   flags: [
     {
+      // The list no longer filters by test id: --test-id reads the real
+      // detail route, the same one `emails inbox-placement-tests get` binds.
       flag: "--test-id <id>",
       summary: "One test: live status + per-provider placement (re-poll ~30s until completed)"
-    }
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    INPUT_FLAG
   ],
   examples: [
     "brew-cli emails get-inbox-placement-results eml_2SmZOWV3ZQ7W5x6g3m4p",
     "brew-cli emails get-inbox-placement-results eml_2SmZOWV3ZQ7W5x6g3m4p --test-id ibp_2f1c9d8a"
   ],
-  run: async ({ ctx, args, flags }) => ({
-    data: await ctx.client().emails.getInboxPlacementResults(
-      asSdkInput({
-        emailId: args.emailId ?? "",
-        testId: flagString(flags.testId)
-      })
-    )
-  })
+  run: async ({ ctx, args, flags }) => {
+    const emailId = args.emailId ?? "";
+    const testId = flagString(flags.testId);
+    const inboxPlacementTests = ctx.client().emails.inboxPlacementTests;
+    if (testId !== void 0) {
+      return { data: await inboxPlacementTests.get(emailId, testId) };
+    }
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const input = mergeInput(base, {
+      emailId,
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    });
+    return {
+      data: await inboxPlacementTests.list(
+        asSdkInput(input)
+      )
+    };
+  }
 });
 
 // src/commands/emails/groups/create.ts
@@ -4558,6 +5630,29 @@ var emailsGroupsDeleteCommand = defineCommand({
   })
 });
 
+// src/commands/emails/groups/get.ts
+var emailsGroupsGetCommand = defineCommand({
+  path: ["emails", "groups", "get"],
+  summary: "Fetch one email group by id \u2014 the bare row",
+  sdkMethod: "emailGroups.get",
+  route: { method: "GET", path: "/v1/email-groups/{groupId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "groupId",
+      summary: "Group id (`grp_\u2026`, or the literal `ungrouped`)",
+      isRequired: true
+    }
+  ],
+  examples: [
+    "brew-cli emails groups get grp_2f1c9d8a",
+    "brew-cli emails groups get ungrouped"
+  ],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().emailGroups.get(args.groupId ?? "")
+  })
+});
+
 // src/commands/emails/groups/list.ts
 var emailsGroupsListCommand = defineCommand({
   path: ["emails", "groups", "list"],
@@ -4715,8 +5810,16 @@ var emailsImportFigmaCommand = defineCommand({
       summary: "Representation returned in content: jsx (default) or html"
     },
     {
-      flag: "--subject-line <text>",
-      summary: "The design's default inbox subject line"
+      flag: "--subject-line <text>",
+      summary: "The design's default inbox subject line"
+    },
+    {
+      flag: "--group-id <groupId>",
+      summary: "File the design under an existing group (grp_\u2026), or ungrouped"
+    },
+    {
+      flag: "--group-name <name>",
+      summary: "File the design under a group found (or created) by this name; not with --group-id"
     },
     IDEMPOTENCY_FLAG
   ],
@@ -4734,13 +5837,20 @@ var emailsImportFigmaCommand = defineCommand({
     const title = flagString(flags.title);
     const format = flagString(flags.format);
     const subjectLine = flagString(flags.subjectLine);
+    const groupId = flagString(flags.groupId);
+    const groupName = flagString(flags.groupName);
+    if (groupId !== void 0 && groupName !== void 0) {
+      throw new CliUsageError("Pass --group-id or --group-name, not both.");
+    }
     return {
       data: await ctx.client().emails.importFigma(
         asSdkInput({
           figmaUrl,
           ...title === void 0 ? {} : { title },
           ...format === void 0 ? {} : { format },
-          ...subjectLine === void 0 ? {} : { subjectLine }
+          ...subjectLine === void 0 ? {} : { subjectLine },
+          ...groupId === void 0 ? {} : { groupId },
+          ...groupName === void 0 ? {} : { groupName }
         }),
         requestOptions(flags)
       )
@@ -4748,53 +5858,108 @@ var emailsImportFigmaCommand = defineCommand({
   }
 });
 
+// src/commands/emails/inbox-placement-tests/get.ts
+var emailsInboxPlacementTestsGetCommand = defineCommand({
+  path: ["emails", "inbox-placement-tests", "get"],
+  summary: "Fetch one inbox-placement (seed) test \u2014 the bare row, re-poll ~30s until completed",
+  sdkMethod: "emails.inboxPlacementTests.get",
+  route: {
+    method: "GET",
+    path: "/v1/emails/{emailId}/inbox-placement-tests/{testId}"
+  },
+  commandClass: "read",
+  args: [
+    {
+      name: "emailId",
+      summary: "Design id the test ran on",
+      isRequired: true
+    },
+    {
+      name: "testId",
+      summary: "Test id returned by `emails create-inbox-placement-test`",
+      isRequired: true
+    }
+  ],
+  examples: [
+    "brew-cli emails inbox-placement-tests get eml_2SmZOWV3ZQ7W5x6g3m4p ibp_2f1c9d8a"
+  ],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().emails.inboxPlacementTests.get(args.emailId ?? "", args.testId ?? "")
+  })
+});
+
 // src/commands/emails/list.ts
 var emailsListCommand = defineCommand({
   path: ["emails", "list"],
-  summary: "List email designs (the single email read)",
+  summary: "List email designs; one design is `emails get`",
   sdkMethod: "emails.list",
   route: { method: "GET", path: "/v1/emails" },
   commandClass: "read",
   flags: [
     {
       flag: "--status <status>",
-      summary: "Filter by status: streaming | complete | error"
+      summary: "Filter by status: generating | ready | failed"
     },
     {
       flag: "--group-id <groupId>",
       summary: "Filter by one group id; use ungrouped for no saved group"
     },
     {
-      flag: "--sort <field>",
-      summary: "Sort by updatedAt | createdAt | title"
+      flag: "--sort-by <field>",
+      summary: "Timestamp the page is ordered by and that --since/--until bound: updatedAt (default) | createdAt"
+    },
+    {
+      flag: "--since <iso>",
+      summary: "Inclusive lower bound on the --sort-by timestamp (ISO-8601)"
+    },
+    {
+      flag: "--until <iso>",
+      summary: "Inclusive upper bound on the --sort-by timestamp (ISO-8601)"
+    },
+    { flag: "--sort <field>", summary: "0.6 alias of --sort-by" },
+    {
+      flag: "--order <order>",
+      summary: "0.6 flag: pages are newest first; only desc is accepted"
+    },
+    {
+      flag: "--created-at-from <iso>",
+      summary: "0.6 alias of --sort-by createdAt --since <iso>"
+    },
+    {
+      flag: "--created-at-to <iso>",
+      summary: "0.6 alias of --sort-by createdAt --until <iso>"
+    },
+    {
+      flag: "--updated-at-from <iso>",
+      summary: "0.6 alias of --sort-by updatedAt --since <iso>"
+    },
+    {
+      flag: "--updated-at-to <iso>",
+      summary: "0.6 alias of --sort-by updatedAt --until <iso>"
     },
-    { flag: "--order <order>", summary: "Sort order: asc | desc" },
-    { flag: "--created-at-from <iso>", summary: "Created at or after (ISO)" },
-    { flag: "--created-at-to <iso>", summary: "Created at or before (ISO)" },
-    { flag: "--updated-at-from <iso>", summary: "Updated at or after (ISO)" },
-    { flag: "--updated-at-to <iso>", summary: "Updated at or before (ISO)" },
     LIMIT_FLAG,
     CURSOR_FLAG,
     ALL_FLAG,
     INPUT_FLAG
   ],
   examples: [
-    "brew-cli emails list --status complete --limit 10",
-    "brew-cli emails list --group-id ungrouped --sort title --order asc",
-    "brew-cli emails list --updated-at-from 2026-08-01T00:00:00Z",
+    "brew-cli emails list --status ready --limit 10",
+    "brew-cli emails list --group-id ungrouped",
+    "brew-cli emails list --sort-by createdAt --since 2026-08-01T00:00:00Z",
     "brew-cli emails list --all --json"
   ],
   run: async ({ ctx, flags }) => {
+    const legacy = legacyWindow(
+      flags,
+      flagString(flags.sortBy) ?? flagString(flags.sort)
+    );
     const base = await readJsonFlag(ctx, flags.input, "--input");
     const input = mergeInput(base, {
       status: flagString(flags.status),
       groupId: flagString(flags.groupId),
-      sort: flagString(flags.sort),
-      order: flagString(flags.order),
-      createdAtFrom: flagString(flags.createdAtFrom),
-      createdAtTo: flagString(flags.createdAtTo),
-      updatedAtFrom: flagString(flags.updatedAtFrom),
-      updatedAtTo: flagString(flags.updatedAtTo),
+      sortBy: flagString(flags.sortBy) ?? flagString(flags.sort) ?? legacy.sortBy,
+      from: flagString(flags.since) ?? legacy.from,
+      to: flagString(flags.until) ?? legacy.to,
       limit: flagInt(flags.limit, "--limit"),
       cursor: flagString(flags.cursor)
     });
@@ -4818,6 +5983,40 @@ var emailsListCommand = defineCommand({
     return { data: result, human: renderEmails(result.data) };
   }
 });
+function legacyWindow(flags, explicitSortBy) {
+  const order = flagString(flags.order);
+  if (order !== void 0 && order !== "desc") {
+    throw new CliUsageError(
+      "GET /v1/emails pages newest first only; --order asc has no equivalent."
+    );
+  }
+  const created = {
+    from: flagString(flags.createdAtFrom),
+    to: flagString(flags.createdAtTo)
+  };
+  const updated = {
+    from: flagString(flags.updatedAtFrom),
+    to: flagString(flags.updatedAtTo)
+  };
+  const hasCreated = created.from !== void 0 || created.to !== void 0;
+  const hasUpdated = updated.from !== void 0 || updated.to !== void 0;
+  if (hasCreated && hasUpdated) {
+    throw new CliUsageError(
+      "The API bounds one timestamp per page: pass --created-at-* or --updated-at-*, not both (or --sort-by with --since/--until)."
+    );
+  }
+  if (!(hasCreated || hasUpdated)) {
+    return { sortBy: void 0, from: void 0, to: void 0 };
+  }
+  const column = hasCreated ? "createdAt" : "updatedAt";
+  if (explicitSortBy !== void 0 && explicitSortBy !== column) {
+    const prefix = hasCreated ? "--created-at-*" : "--updated-at-*";
+    throw new CliUsageError(
+      `${prefix} bounds ${column}, but the page is ordered by ${explicitSortBy}; the API bounds the --sort-by timestamp only.`
+    );
+  }
+  return { sortBy: column, ...hasCreated ? created : updated };
+}
 function renderEmails(rows) {
   if (rows.length === 0) {
     return "No email designs found.";
@@ -4834,7 +6033,7 @@ function renderEmails(rows) {
 // src/commands/emails/preview-clients.ts
 var emailsPreviewClientsCommand = defineCommand({
   path: ["emails", "preview-clients"],
-  summary: "Render the design across real email clients (10 credits)",
+  summary: "Start a rendering job across real email clients (10 credits); poll it with `emails get-client-preview`",
   sdkMethod: "emails.previewClients",
   route: { method: "POST", path: "/v1/emails/{emailId}/client-previews" },
   commandClass: "write",
@@ -4847,25 +6046,49 @@ var emailsPreviewClientsCommand = defineCommand({
       flag: "--clients <ids...>",
       summary: "Client id(s) to render, repeatable (e.g. applemail16 iphone16_18); default: a popular spread"
     },
+    {
+      flag: "--email-version-id <id>",
+      summary: "Render this saved version (default: the latest)"
+    },
     IDEMPOTENCY_FLAG
   ],
   examples: [
     "brew-cli emails preview-clients eml_2SmZOWV3ZQ7W5x6g3m4p",
-    "brew-cli emails preview-clients eml_2SmZOWV3ZQ7W5x6g3m4p --clients applemail16 outlook2021_win11_lm_dt"
+    "brew-cli emails preview-clients eml_2SmZOWV3ZQ7W5x6g3m4p --clients applemail16 outlook2021_win11_lm_dt",
+    'PREVIEW_ID=$(brew-cli emails preview-clients eml_2SmZOWV3ZQ7W5x6g3m4p --json | jq -r .previewId) && brew-cli emails get-client-preview "$PREVIEW_ID"'
   ],
+  // The API answers 202 with the admitted job (or 200 with the existing job
+  // for the same version and clients): `previewId`, its `status` and
+  // per-client progress. Screenshots arrive on the job once it settles, so
+  // `emails get-client-preview <previewId>` is how they are read.
   run: async ({ ctx, args, flags }) => {
     const clients = toStringArray(flags.clients);
-    return {
-      data: await ctx.client().emails.previewClients(
-        asSdkInput({
-          emailId: args.emailId ?? "",
-          ...clients === void 0 ? {} : { clients }
-        }),
-        requestOptions(flags)
-      )
-    };
+    const emailVersionId = flagString(flags.emailVersionId);
+    const job = await ctx.client().emails.previewClients(
+      asSdkInput({
+        emailId: args.emailId ?? "",
+        ...clients === void 0 ? {} : { clients },
+        ...emailVersionId === void 0 ? {} : { emailVersionId }
+      }),
+      requestOptions(flags)
+    );
+    const hint = pollHint(job);
+    if (hint !== void 0) {
+      progress(ctx, hint);
+    }
+    return { data: job };
   }
 });
+function pollHint(job) {
+  if (typeof job !== "object" || job === null || !("previewId" in job) || !("status" in job)) {
+    return;
+  }
+  const { previewId, status } = job;
+  if (typeof previewId !== "string" || status !== "queued" && status !== "running") {
+    return;
+  }
+  return `Rendering job ${previewId} is ${status}. Poll it with: brew-cli emails get-client-preview ${previewId}`;
+}
 
 // src/commands/emails/restore.ts
 var emailsRestoreCommand = defineCommand({
@@ -4879,19 +6102,24 @@ var emailsRestoreCommand = defineCommand({
   ],
   // --version is taken by the CLI itself, hence --to-version.
   flags: [
-    { flag: "--to-version <n>", summary: "Version number to restore" },
+    {
+      flag: "--to-version <emailVersionId>",
+      summary: "Version id to restore (from `emails get <emailId> --include versions`)"
+    },
     IDEMPOTENCY_FLAG
   ],
-  examples: ["brew-cli emails restore eml_2SmZOWV3ZQ7W5x6g3m4p --to-version 2"],
+  examples: [
+    "brew-cli emails restore eml_2SmZOWV3ZQ7W5x6g3m4p --to-version emv_7Hq2"
+  ],
   run: async ({ ctx, args, flags }) => {
-    const version = flagInt(flags.toVersion, "--to-version");
-    if (version === void 0) {
+    const emailVersionId = flagString(flags.toVersion);
+    if (emailVersionId === void 0) {
       throw new CliUsageError(
-        "--to-version is required (see `brew-cli emails get <emailId> --include versions`)."
+        "--to-version is required (a version id; see `brew-cli emails get <emailId> --include versions`)."
       );
     }
     const result = await ctx.client().emails.restore(
-      { emailId: args.emailId ?? "", version },
+      { emailId: args.emailId ?? "", emailVersionId },
       requestOptions(flags)
     );
     return { data: result };
@@ -5061,6 +6289,26 @@ var fieldsDeleteCommand = defineCommand({
   })
 });
 
+// src/commands/fields/get.ts
+var fieldsGetCommand = defineCommand({
+  path: ["fields", "get"],
+  summary: "Fetch one contact field definition by name \u2014 the bare row",
+  sdkMethod: "fields.get",
+  route: { method: "GET", path: "/v1/fields/{fieldName}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "fieldName",
+      summary: "Field name (a core column or a custom field)",
+      isRequired: true
+    }
+  ],
+  examples: ["brew-cli fields get loyalty_tier"],
+  run: async ({ ctx, args }) => ({
+    data: await ctx.client().fields.get(args.fieldName ?? "")
+  })
+});
+
 // src/commands/fields/list.ts
 var fieldsListCommand = defineCommand({
   path: ["fields", "list"],
@@ -5068,9 +6316,221 @@ var fieldsListCommand = defineCommand({
   sdkMethod: "fields.list",
   route: { method: "GET", path: "/v1/fields" },
   commandClass: "read",
-  examples: ["brew-cli fields list"],
-  run: async ({ ctx }) => ({ data: await ctx.client().fields.list() })
+  flags: [
+    {
+      flag: "--include <tokens>",
+      summary: "Expansions: coverage (per-field fill stats: percent of contacts with a value, and top values)"
+    },
+    {
+      flag: "--audience-id <audienceId>",
+      summary: "Scope --include coverage to one saved audience (ignored without it)"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG
+  ],
+  examples: [
+    "brew-cli fields list",
+    "brew-cli fields list --include coverage",
+    "brew-cli fields list --include coverage --audience-id aud_2SmZOWV3ZQ7W5x6g3m4p --all --json"
+  ],
+  run: async ({ ctx, flags }) => {
+    const input = {
+      include: flagString(flags.include),
+      audienceId: flagString(flags.audienceId),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    };
+    const fields = ctx.client().fields;
+    if (flags.all === true) {
+      const rows = await collectAll(
+        ctx,
+        (cursor) => fields.list(
+          asSdkInput({
+            ...input,
+            ...cursor === void 0 ? {} : { cursor }
+          })
+        )
+      );
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } }
+      };
+    }
+    return { data: await fields.list(asSdkInput(input)) };
+  }
+});
+
+// src/commands/flows/get.ts
+var flowsGetCommand = defineCommand({
+  path: ["flows", "get"],
+  summary: "Fetch one public email flow by brand domain, with every step (day offset, wait, subject, template id)",
+  sdkMethod: "flows.get",
+  route: { method: "GET", path: "/v1/flows/{slug}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "slug",
+      summary: "The brand domain a `flows list` card carries (e.g. brew.new)",
+      isRequired: true
+    }
+  ],
+  flags: [
+    {
+      flag: "--include <keys>",
+      summary: "Comma-separated expansions: html (each step\u2019s rendered HTML, best-effort per step)"
+    }
+  ],
+  examples: [
+    "brew-cli flows get brew.new",
+    "brew-cli flows get brew.new --include html --json"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const include = flagString(flags.include);
+    const flow = await ctx.client().flows.get(
+      args.slug ?? "",
+      include === void 0 ? void 0 : { include }
+    );
+    return { data: flow, human: renderSteps(flow) };
+  }
+});
+function renderSteps(flow) {
+  const header = `${flow.title} \u2014 ${flow.brand.name} (${flow.slug}), ${flow.emailCount} emails over ${flow.spanDays} days${flow.anchor === void 0 ? "" : `, day 0 = ${flow.anchor}`}`;
+  const table = renderTable(
+    (flow.steps ?? []).map((step) => ({
+      order: step.order,
+      day: step.dayOffset,
+      wait: step.delayDays,
+      subject: step.subject,
+      category: step.category,
+      emailId: step.emailId
+    })),
+    [
+      { key: "order", header: "#" },
+      { key: "day", header: "DAY" },
+      { key: "wait", header: "WAIT" },
+      { key: "subject", header: "SUBJECT" },
+      { key: "category", header: "CATEGORY" },
+      { key: "emailId", header: "TEMPLATE" }
+    ]
+  );
+  return `${header}
+
+${table}`;
+}
+
+// src/commands/flows/list.ts
+var flowsListCommand = defineCommand({
+  path: ["flows", "list"],
+  summary: "List public email flows (real multi-step sequences by brand) as cards; `flows get <slug>` reads one",
+  sdkMethod: "flows.list",
+  route: { method: "GET", path: "/v1/flows" },
+  commandClass: "read",
+  flags: [
+    {
+      // --brand is taken by the global brand-selection flag.
+      flag: "--brand-domain <domain>",
+      summary: "Filter the list by brand domain"
+    },
+    {
+      flag: "--category <category>",
+      summary: "Filter by dominant step category (welcome, newsletter, \u2026)"
+    },
+    {
+      flag: "--type <type>",
+      summary: "Filter by how the sequence starts: signup | newsletter"
+    },
+    {
+      flag: "--semantic <text>",
+      summary: "Semantic search over the sequences (relevance order)"
+    },
+    {
+      flag: "--sort <order>",
+      summary: "List order: newest (default) | emails | span | remixes"
+    },
+    {
+      flag: "--slug <domain>",
+      summary: "0.6 shim: read ONE flow with its steps as a single-row page (`flows get <slug>` is the real read)"
+    },
+    {
+      flag: "--include <keys>",
+      summary: "With --slug only: `html` adds each step's rendered HTML"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
+  ],
+  examples: [
+    "brew-cli flows list --type signup --sort emails",
+    "brew-cli flows list --brand-domain brew.new --json",
+    'brew-cli flows list --semantic "developer onboarding drip"'
+  ],
+  run: async ({ ctx, flags }) => {
+    const flows = ctx.client().flows;
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const slug = flagString(flags.slug) ?? inputField(base, "slug");
+    const include = flagString(flags.include) ?? inputField(base, "include");
+    if (slug !== void 0) {
+      const flow = await flows.get(
+        slug,
+        include === void 0 ? void 0 : { include }
+      );
+      return { data: singleRowPage(flow), human: renderFlows([flow]) };
+    }
+    if (include !== void 0) {
+      throw includeRidesDetailRead("flows get", "--slug");
+    }
+    const input = mergeInput(base, {
+      brand: flagString(flags.brandDomain),
+      category: flagString(flags.category),
+      type: flagString(flags.type),
+      semantic: flagString(flags.semantic),
+      sort: flagString(flags.sort),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    });
+    if (flags.all === true) {
+      const rows = await collectAll(
+        ctx,
+        (cursor) => flows.list(
+          asSdkInput({
+            ...input,
+            ...cursor === void 0 ? {} : { cursor }
+          })
+        )
+      );
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } },
+        human: renderFlows(rows)
+      };
+    }
+    const result = await flows.list(asSdkInput(input));
+    return { data: result, human: renderFlows(result.data) };
+  }
 });
+function renderFlows(rows) {
+  if (rows.length === 0) {
+    return "No flows found.";
+  }
+  return renderTable(
+    rows.map((row) => ({
+      slug: row.slug,
+      brand: row.brand.name,
+      type: row.type,
+      category: row.category,
+      emails: row.emailCount,
+      spanDays: row.spanDays
+    })),
+    [
+      { key: "slug", header: "SLUG" },
+      { key: "brand", header: "BRAND" },
+      { key: "type", header: "TYPE" },
+      { key: "category", header: "CATEGORY" },
+      { key: "emails", header: "EMAILS" },
+      { key: "spanDays", header: "SPAN (DAYS)" }
+    ]
+  );
+}
 
 // src/commands/health.ts
 var healthCommand = defineCommand({
@@ -5092,9 +6552,31 @@ var integrationsListCommand = defineCommand({
   sdkMethod: "integrations.list",
   route: { method: "GET", path: "/v1/integrations" },
   commandClass: "read",
+  flags: [LIMIT_FLAG, CURSOR_FLAG, ALL_FLAG],
   examples: ["brew-cli integrations list", "brew-cli integrations list --json"],
-  run: async ({ ctx }) => {
-    const result = await ctx.client().integrations.list();
+  run: async ({ ctx, flags }) => {
+    const limit = flagInt(flags.limit, "--limit");
+    const cursor = flagString(flags.cursor);
+    if (limit === void 0 && cursor === void 0 && flags.all !== true) {
+      const result2 = await ctx.client().integrations.list();
+      return { data: result2, human: renderIntegrations(result2.data) };
+    }
+    const page = (after) => rawRequest(ctx, {
+      method: "GET",
+      path: "/v1/integrations",
+      query: {
+        limit: limit === void 0 ? void 0 : String(limit),
+        cursor: after
+      }
+    });
+    if (flags.all === true) {
+      const rows = await collectAll(ctx, (next) => page(next ?? cursor));
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } },
+        human: renderIntegrations(rows)
+      };
+    }
+    const result = await page(cursor);
     return { data: result, human: renderIntegrations(result.data) };
   }
 });
@@ -5198,6 +6680,35 @@ var sendsCancelCommand = defineCommand({
   })
 });
 
+// src/commands/sends/get.ts
+var sendsGetCommand = defineCommand({
+  path: ["sends", "get"],
+  summary: "Fetch one send by id \u2014 the bare row with its lifetime stats",
+  sdkMethod: "sends.get",
+  route: { method: "GET", path: "/v1/sends/{sendId}" },
+  commandClass: "read",
+  args: [{ name: "sendId", summary: "Send id to fetch", isRequired: true }],
+  flags: [
+    {
+      flag: "--include <tokens>",
+      summary: "Comma-separated expansions: events"
+    }
+  ],
+  examples: [
+    "brew-cli sends get snd_9f2kX",
+    "brew-cli sends get snd_9f2kX --include events"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const include = flagString(flags.include);
+    return {
+      data: await ctx.client().sends.get(
+        args.sendId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
+  }
+});
+
 // src/commands/sends/pause.ts
 var sendsPauseCommand = defineCommand({
   path: ["sends", "pause"],
@@ -5216,7 +6727,7 @@ var sendsPauseCommand = defineCommand({
 // src/commands/sends/resume.ts
 var sendsResumeCommand = defineCommand({
   path: ["sends", "resume"],
-  summary: "Resume a paused gradual send (the unsent tail is re-spread)",
+  summary: "Resume a paused gradual send (the unsent tail is re-spread); the send reports `running` again",
   sdkMethod: "sends.resume",
   route: { method: "POST", path: "/v1/sends/{sendId}/resume" },
   commandClass: "write",
@@ -5228,6 +6739,41 @@ var sendsResumeCommand = defineCommand({
   })
 });
 
+// src/commands/templates/get.ts
+var templatesGetCommand = defineCommand({
+  path: ["templates", "get"],
+  summary: "Fetch one public template: its links and the referenceEmailId to remix; --include html adds its HTML",
+  sdkMethod: null,
+  isRawTransport: true,
+  route: { method: "GET", path: "/v1/templates/{templateId}" },
+  commandClass: "read",
+  args: [
+    {
+      name: "templateId",
+      summary: "Template id: the TEMPLATE column (emailId) of `templates list`",
+      isRequired: true
+    }
+  ],
+  flags: [
+    {
+      flag: "--include <tokens>",
+      summary: "Expansions: html (the rendered HTML; a large page arrives as a content.url download link instead)"
+    }
+  ],
+  examples: [
+    "brew-cli templates get seed-vercel-newsletter",
+    "brew-cli templates get seed-vercel-newsletter --include html --json"
+  ],
+  run: async ({ ctx, args, flags }) => {
+    const body = await rawRequest(ctx, {
+      method: "GET",
+      path: `/v1/templates/${encodeURIComponent(args.templateId ?? "")}`,
+      query: { include: flagString(flags.include) }
+    });
+    return { data: body };
+  }
+});
+
 // src/commands/templates/list.ts
 var templatesListCommand = defineCommand({
   path: ["templates", "list"],
@@ -5535,6 +7081,7 @@ var ALL_COMMANDS = [
   configGetCommand,
   configSetCommand,
   configUnsetCommand,
+  contactsListCommand,
   contactsSearchCommand,
   contactsGetCommand,
   contactsCountCommand,
@@ -5546,10 +7093,12 @@ var ALL_COMMANDS = [
   contactsValidateCommand,
   contactsImportCsvCommand,
   fieldsListCommand,
+  fieldsGetCommand,
   fieldsCreateCommand,
   fieldsDeleteCommand,
   emailsListCommand,
   emailsGroupsListCommand,
+  emailsGroupsGetCommand,
   emailsGroupsCreateCommand,
   emailsGroupsUpdateCommand,
   emailsGroupsDeleteCommand,
@@ -5563,10 +7112,15 @@ var ALL_COMMANDS = [
   emailsDeleteCommand,
   emailsExportCommand,
   emailsAuditCommand,
+  emailsGetAuditCommand,
   emailsPreviewClientsCommand,
+  emailsGetClientPreviewCommand,
   emailsCreateInboxPlacementTestCommand,
   emailsGetInboxPlacementResultsCommand,
+  emailsInboxPlacementTestsGetCommand,
   emailsSendCommand,
+  sendsListCommand,
+  sendsGetCommand,
   sendsCancelCommand,
   sendsPauseCommand,
   sendsResumeCommand,
@@ -5588,6 +7142,7 @@ var ALL_COMMANDS = [
   automationsTestCommand,
   automationsRunCommand,
   automationsTriggersListCommand,
+  automationsTriggersGetCommand,
   automationsTriggersReadyCommand,
   automationsTriggersContractGetCommand,
   automationsTriggersContractPutCommand,
@@ -5599,12 +7154,21 @@ var ALL_COMMANDS = [
   automationsTriggersDeleteCommand,
   automationsTriggersFireCommand,
   automationsRunsListCommand,
+  automationsRunsGetCommand,
+  automationsRunsCancelCommand,
   automationsAudienceRunsListCommand,
+  automationsAudienceRunsGetCommand,
+  automationsAudienceRunsPauseCommand,
+  automationsAudienceRunsResumeCommand,
+  automationsAudienceRunsCancelCommand,
   automationsAudienceRunsControlCommand,
+  automationsTriggerInstancesListCommand,
+  automationsTriggerInstancesGetCommand,
   analyticsOverviewCommand,
   analyticsCampaignsCommand,
   analyticsAutomationsCommand,
   analyticsEventsCommand,
+  analyticsEventCountsCommand,
   analyticsSendsListCommand,
   analyticsSendsGetCommand,
   analyticsTriggerInstancesListCommand,
@@ -5624,12 +7188,20 @@ var ALL_COMMANDS = [
   domainsHealthCommand,
   domainsUpdateCommand,
   domainsDeleteCommand,
+  domainsUnsubscribesListCommand,
+  domainsUnsubscribesAddCommand,
+  domainsUnsubscribesRemoveCommand,
+  domainsUnsubscribesImportCommand,
+  domainsUnsubscribesExportCommand,
   contentGenerateImageCommand,
   contentGifCommand,
   contentTransformCommand,
   contentHtmlToPngCommand,
   contentAddImageCommand,
   templatesListCommand,
+  templatesGetCommand,
+  flowsListCommand,
+  flowsGetCommand,
   integrationsListCommand,
   chatsGetCommand,
   healthCommand,
@@ -5642,7 +7214,8 @@ var ALL_COMMANDS = [
 
 // src/cli.ts
 var GROUP_SUMMARIES = {
-  analytics: "Read campaign, automation, send, and event analytics",
+  analytics: "Reports: overview, events, and automation analytics",
+  "audience-runs": "Manual-audience launches: read, pause, resume, cancel",
   "api-keys": "Manage organization API keys",
   audiences: "Manage audience segments",
   automations: "Manage automation graphs, triggers, and runs",
@@ -5656,15 +7229,17 @@ var GROUP_SUMMARIES = {
   domains: "Manage sending domains",
   emails: "Manage email designs and send campaigns",
   fields: "Manage custom contact fields",
+  flows: "Browse public email flows (real multi-step sequences by brand)",
   groups: "Manage email folders (groups)",
   integrations: "Read the connected-integration catalog",
-  sends: "Control in-flight or scheduled sends",
+  "inbox-placement-tests": "Inbox placement (seed) test results",
+  sends: "Read sends, and control one in flight or scheduled",
   templates: "Browse the template gallery",
   contract: "Stored payload contracts (get, put, validate)",
   contracts: "Payload-contract helpers",
   triggers: "Manage trigger events",
-  runs: "Automation run history",
-  "trigger-instances": "Fired trigger instances"
+  runs: "Automation run history, and cancel one in-flight run",
+  "trigger-instances": "Fired trigger instances (the inbound-fire audit log)"
 };
 var AGENT_HELP_FOOTER = `
 Environment: