@brew.new/cli 0.5.0 → 0.8.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.5.0" ;
+var CLI_VERSION = "0.8.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",
@@ -668,58 +735,128 @@ function renderAutomationRows(rows) {
   ]);
 }
 
-// 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" },
+// 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: [LIMIT_FLAG, CURSOR_FLAG, ALL_FLAG, INPUT_FLAG],
+  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 analytics campaigns",
-    "brew-cli analytics campaigns --all --json"
+    "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)
     });
-    const analytics = ctx.client().analytics;
-    if (flags.all === true) {
-      const rows = await collectAll(
-        ctx,
-        (cursor) => analytics.campaigns(
-          asSdkInput({
-            ...input,
-            ...cursor === void 0 ? {} : { cursor }
-          })
-        )
-      );
-      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) };
+    return await listSends(ctx, input, flags.all === true);
   }
 });
-function renderCampaigns(rows) {
+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 campaign analytics rows.";
+    return "No sends found.";
   }
   return renderTable(rows, [
     { key: "sendId", header: "SEND" },
-    { key: "title", header: "TITLE" },
+    { key: "kind", header: "KIND" },
     { key: "status", header: "STATUS" },
-    { key: "sentAt", header: "SENT AT" }
+    { key: "subject", header: "SUBJECT" }
   ]);
 }
 
+// src/commands/analytics/campaigns.ts
+var analyticsCampaignsCommand = defineCommand({
+  path: ["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: [
+    "brew-cli analytics campaigns",
+    "brew-cli analytics campaigns --all --json"
+  ],
+  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)
+    });
+    return await listSends(ctx, input, flags.all === true);
+  }
+});
+
 // src/commands/analytics/events.ts
 var analyticsEventsCommand = defineCommand({
   path: ["analytics", "events"],
@@ -730,7 +867,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 +891,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 +992,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 +1015,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,59 +1071,105 @@ 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) {
+
+// 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"
+    },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
+  ],
+  examples: [
+    "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),
+      limit: flagInt(flags.limit, "--limit"),
+      cursor: flagString(flags.cursor)
+    });
+    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 sends found.";
+    return "No trigger instances found.";
   }
   return renderTable(rows, [
-    { key: "sendId", header: "SEND" },
-    { key: "kind", header: "KIND" },
-    { key: "status", header: "STATUS" },
-    { key: "subject", header: "SUBJECT" }
+    { key: "triggerInstanceId", header: "INSTANCE" },
+    { key: "source", header: "SOURCE" },
+    { key: "state", header: "STATE" },
+    { key: "receivedAt", header: "RECEIVED" }
   ]);
 }
 
 // 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" },
+  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: [
     {
@@ -984,7 +1178,7 @@ var analyticsTriggerInstancesListCommand = defineCommand({
     },
     {
       flag: "--trigger-instance <triggerInstanceId>",
-      summary: "Fetch one instance (single-row page)"
+      summary: "0.6 shim: read ONE instance as a single-row page (`automations trigger-instances get` is the real read)"
     },
     LIMIT_FLAG,
     CURSOR_FLAG,
@@ -992,50 +1186,24 @@ var analyticsTriggerInstancesListCommand = defineCommand({
     INPUT_FLAG
   ],
   examples: [
-    "brew-cli analytics trigger-instances list --trigger tev_123",
+    "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 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);
   }
 });
-function renderInstances(rows) {
-  if (rows.length === 0) {
-    return "No trigger instances found.";
-  }
-  return renderTable(rows, [
-    { key: "triggerInstanceId", header: "INSTANCE" },
-    { key: "source", header: "SOURCE" },
-    { key: "state", header: "STATE" },
-    { key: "receivedAt", header: "RECEIVED" }
-  ]);
-}
 
 // src/lib/raw-request.ts
 async function rawRequest(ctx, request) {
@@ -1107,26 +1275,33 @@ function buildRawHeaders(input) {
 }
 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 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");
+  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") ?? "internal_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 }
+    ...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);
@@ -1479,10 +1654,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 +1664,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 +1701,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 +1776,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 +1826,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,57 +1836,181 @@ 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
@@ -1755,10 +2078,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 +2092,7 @@ var automationsGetCommand = defineCommand({
   flags: [
     {
       flag: "--include <tokens>",
-      summary: "Comma-separated expansions: graph | versions"
+      summary: "Comma-separated expansions: graph, versions"
     }
   ],
   examples: [
@@ -1778,23 +2100,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 +2230,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 +2240,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 +2268,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 +2360,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 +2389,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 +2418,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 +2482,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 +2777,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 +2831,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 +2879,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 +2893,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
@@ -2962,37 +3419,21 @@ 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
@@ -3033,22 +3474,23 @@ var contactsImportCsvCommand = defineCommand({
   }
 });
 
-// src/commands/contacts/search.ts
-var contactsSearchCommand = defineCommand({
-  path: ["contacts", "search"],
-  summary: "Search contacts with structured filters (the contacts read)",
-  sdkMethod: "contacts.search",
-  route: { method: "POST", path: "/v1/contacts/search" },
+// 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: "--filter <filters...>",
-      summary: "Structured filter field:operator[:value], repeatable"
+      flag: "--audience <audienceId>",
+      summary: "Only members of this saved audience"
+    },
+    {
+      flag: "--sort <field>",
+      summary: "Any core column or custom field (default createdAt)"
     },
-    { flag: "--audience <audienceId>", summary: "Scope to one audience" },
-    { flag: "--logic <logic>", summary: "Filter combinator: and | or" },
-    { flag: "--sort <field>", summary: "Sort field" },
     { flag: "--order <order>", summary: "Sort order: asc | desc" },
     LIMIT_FLAG,
     CURSOR_FLAG,
@@ -3056,17 +3498,15 @@ var contactsSearchCommand = defineCommand({
     INPUT_FLAG
   ],
   examples: [
-    "brew-cli contacts search --filter email:equals:jane@example.com",
-    "brew-cli contacts search --search jane --limit 10",
-    "brew-cli contacts search --all --json"
+    "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),
-      filters: parseFilterFlags(flags.filter),
       audienceId: flagString(flags.audience),
-      logic: flagString(flags.logic),
       sort: flagString(flags.sort),
       order: flagString(flags.order),
       limit: flagInt(flags.limit, "--limit"),
@@ -3076,7 +3516,7 @@ var contactsSearchCommand = defineCommand({
     if (flags.all === true) {
       const rows = await collectAll(
         ctx,
-        (cursor) => contacts.search(
+        (cursor) => contacts.list(
           asSdkInput({
             ...input,
             ...cursor === void 0 ? {} : { cursor }
@@ -3088,13 +3528,13 @@ var contactsSearchCommand = defineCommand({
         human: renderContacts(rows)
       };
     }
-    const result = await contacts.search(asSdkInput(input));
+    const result = await contacts.list(asSdkInput(input));
     return { data: result, human: renderContacts(result.data) };
   }
 });
 function renderContacts(rows) {
   if (rows.length === 0) {
-    return "No contacts matched.";
+    return "No contacts found.";
   }
   return renderTable(rows, [
     { key: "email", header: "EMAIL" },
@@ -3104,15 +3544,86 @@ function renderContacts(rows) {
   ]);
 }
 
-// src/commands/contacts/update.ts
-var contactsUpdateCommand = defineCommand({
-  path: ["contacts", "update"],
-  summary: "Partially update one contact (PATCH; never retried)",
-  sdkMethod: "contacts.patch",
-  route: { method: "PATCH", path: "/v1/contacts/{email}" },
-  commandClass: "write",
-  args: [
-    {
+// src/commands/contacts/search.ts
+var contactsSearchCommand = defineCommand({
+  path: ["contacts", "search"],
+  summary: "Search contacts with structured filters (the contacts read)",
+  sdkMethod: "contacts.search",
+  route: { method: "POST", path: "/v1/contacts/search" },
+  commandClass: "read",
+  flags: [
+    { flag: "--search <text>", summary: "Free-text search" },
+    {
+      flag: "--filter <filters...>",
+      summary: "Structured filter field:operator[:value], repeatable"
+    },
+    { flag: "--audience <audienceId>", summary: "Scope to one audience" },
+    { flag: "--logic <logic>", summary: "Filter combinator: and | or" },
+    { flag: "--sort <field>", summary: "Sort field" },
+    { flag: "--order <order>", summary: "Sort order: asc | desc" },
+    LIMIT_FLAG,
+    CURSOR_FLAG,
+    ALL_FLAG,
+    INPUT_FLAG
+  ],
+  examples: [
+    "brew-cli contacts search --filter email:equals:jane@example.com",
+    "brew-cli contacts search --search jane --limit 10",
+    "brew-cli contacts search --all --json"
+  ],
+  run: async ({ ctx, flags }) => {
+    const base = await readJsonFlag(ctx, flags.input, "--input");
+    const input = mergeInput(base, {
+      search: flagString(flags.search),
+      filters: parseFilterFlags(flags.filter),
+      audienceId: flagString(flags.audience),
+      logic: flagString(flags.logic),
+      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.search(
+          asSdkInput({
+            ...input,
+            ...cursor === void 0 ? {} : { cursor }
+          })
+        )
+      );
+      return {
+        data: { data: rows, pagination: { cursor: null, hasMore: false } },
+        human: renderContacts2(rows)
+      };
+    }
+    const result = await contacts.search(asSdkInput(input));
+    return { data: result, human: renderContacts2(result.data) };
+  }
+});
+function renderContacts2(rows) {
+  if (rows.length === 0) {
+    return "No contacts matched.";
+  }
+  return renderTable(rows, [
+    { key: "email", header: "EMAIL" },
+    { key: "firstName", header: "FIRST" },
+    { key: "lastName", header: "LAST" },
+    { key: "subscribed", header: "SUBSCRIBED" }
+  ]);
+}
+
+// src/commands/contacts/update.ts
+var contactsUpdateCommand = defineCommand({
+  path: ["contacts", "update"],
+  summary: "Partially update one contact (PATCH; never retried)",
+  sdkMethod: "contacts.patch",
+  route: { method: "PATCH", path: "/v1/contacts/{email}" },
+  commandClass: "write",
+  args: [
+    {
       name: "email",
       summary: "Email address of the contact",
       isRequired: true
@@ -3582,8 +4093,56 @@ var contractsInferCommand = defineCommand({
   }
 });
 
+// src/commands/data/run.ts
+var dataRunCommand = defineCommand({
+  path: ["data", "run"],
+  summary: "Run a `db \u2026` command over the brand's data",
+  sdkMethod: "data.run",
+  route: { method: "POST", path: "/v1/data" },
+  commandClass: "read",
+  args: [
+    {
+      name: "command",
+      summary: "The db command line, e.g. 'db find audiences --fields name'",
+      isRequired: true
+    }
+  ],
+  flags: [],
+  examples: [
+    "brew-cli data run 'db ls'",
+    "brew-cli data run 'db find contacts --since 30d --fields email --limit 20'",
+    "brew-cli data run 'db agg analyticsEvents --since 7d --group-by eventType --bucket day'"
+  ],
+  run: async ({ ctx, args }) => {
+    const result = await ctx.client().data.run({
+      command: args.command ?? ""
+    });
+    return {
+      data: result,
+      human: result.output,
+      exitCode: result.exitCode === 0 ? 0 : 1
+    };
+  }
+});
+
 // src/skip-list.ts
 var SDK_SKIP_LIST = [
+  {
+    sdkPath: "automations.triggers.getContract",
+    reason: "covered by `automations triggers contract get` (raw route, bound pre-SDK-v9; SDK-method migration tracked separately)"
+  },
+  {
+    sdkPath: "automations.triggers.putContract",
+    reason: "covered by `automations triggers contract put` (raw route, bound pre-SDK-v9)"
+  },
+  {
+    sdkPath: "automations.triggers.validatePayload",
+    reason: "covered by `automations triggers contract validate` (raw route, bound pre-SDK-v9)"
+  },
+  {
+    sdkPath: "payloadContracts.infer",
+    reason: "covered by `contracts infer` (raw route, bound pre-SDK-v9)"
+  },
   {
     sdkPath: "contacts.searchAll",
     reason: "auto-pager covered by `contacts search --all`"
@@ -3593,12 +4152,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",
@@ -3674,7 +4233,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",
@@ -3865,28 +4424,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
@@ -4136,7 +4682,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,
@@ -4180,9 +4726,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,
@@ -4213,9 +4759,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",
@@ -4235,30 +4785,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 ?? "" }),
@@ -4310,7 +4884,7 @@ var emailsExportCommand = defineCommand({
           provider,
           ...templateName === void 0 ? {} : { templateName },
           // 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)
       )
@@ -4379,10 +4953,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: [
     {
@@ -4394,7 +4967,7 @@ var emailsGetCommand = defineCommand({
   flags: [
     {
       flag: "--include <tokens>",
-      summary: "Comma-separated expansions: html,versions"
+      summary: "Comma-separated expansions: html, versions"
     }
   ],
   examples: [
@@ -4402,31 +4975,89 @@ var emailsGetCommand = defineCommand({
     "brew-cli emails get eml_2SmZOWV3ZQ7W5x6g3m4p --include html,versions"
   ],
   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 }
+    return {
+      data: await ctx.client().emails.get(
+        args.emailId ?? "",
+        include === void 0 ? void 0 : { include }
+      )
+    };
+  }
+});
+
+// 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
+    }
+  ],
+  flags: [LIMIT_FLAG, 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: [
@@ -4438,22 +5069,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
@@ -4510,6 +5157,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"],
@@ -4700,53 +5370,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)
     });
@@ -4770,6 +5495,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.";
@@ -4786,7 +5545,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",
@@ -4799,25 +5558,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({
@@ -4831,19 +5614,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 };
@@ -5013,6 +5801,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"],
@@ -5024,6 +5832,178 @@ var fieldsListCommand = defineCommand({
   run: async ({ ctx }) => ({ data: await ctx.client().fields.list() })
 });
 
+// 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({
   path: ["health"],
@@ -5150,6 +6130,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"],
@@ -5168,7 +6177,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",
@@ -5180,6 +6189,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"],
@@ -5487,6 +6531,7 @@ var ALL_COMMANDS = [
   configGetCommand,
   configSetCommand,
   configUnsetCommand,
+  contactsListCommand,
   contactsSearchCommand,
   contactsGetCommand,
   contactsCountCommand,
@@ -5498,10 +6543,12 @@ var ALL_COMMANDS = [
   contactsValidateCommand,
   contactsImportCsvCommand,
   fieldsListCommand,
+  fieldsGetCommand,
   fieldsCreateCommand,
   fieldsDeleteCommand,
   emailsListCommand,
   emailsGroupsListCommand,
+  emailsGroupsGetCommand,
   emailsGroupsCreateCommand,
   emailsGroupsUpdateCommand,
   emailsGroupsDeleteCommand,
@@ -5515,10 +6562,15 @@ var ALL_COMMANDS = [
   emailsDeleteCommand,
   emailsExportCommand,
   emailsAuditCommand,
+  emailsGetAuditCommand,
   emailsPreviewClientsCommand,
+  emailsGetClientPreviewCommand,
   emailsCreateInboxPlacementTestCommand,
   emailsGetInboxPlacementResultsCommand,
+  emailsInboxPlacementTestsGetCommand,
   emailsSendCommand,
+  sendsListCommand,
+  sendsGetCommand,
   sendsCancelCommand,
   sendsPauseCommand,
   sendsResumeCommand,
@@ -5540,18 +6592,28 @@ var ALL_COMMANDS = [
   automationsTestCommand,
   automationsRunCommand,
   automationsTriggersListCommand,
+  automationsTriggersGetCommand,
   automationsTriggersReadyCommand,
   automationsTriggersContractGetCommand,
   automationsTriggersContractPutCommand,
   automationsTriggersContractValidateCommand,
   contractsInferCommand,
+  dataRunCommand,
   automationsTriggersCreateCommand,
   automationsTriggersUpdateCommand,
   automationsTriggersDeleteCommand,
   automationsTriggersFireCommand,
   automationsRunsListCommand,
+  automationsRunsGetCommand,
+  automationsRunsCancelCommand,
   automationsAudienceRunsListCommand,
+  automationsAudienceRunsGetCommand,
+  automationsAudienceRunsPauseCommand,
+  automationsAudienceRunsResumeCommand,
+  automationsAudienceRunsCancelCommand,
   automationsAudienceRunsControlCommand,
+  automationsTriggerInstancesListCommand,
+  automationsTriggerInstancesGetCommand,
   analyticsOverviewCommand,
   analyticsCampaignsCommand,
   analyticsAutomationsCommand,
@@ -5581,6 +6643,9 @@ var ALL_COMMANDS = [
   contentHtmlToPngCommand,
   contentAddImageCommand,
   templatesListCommand,
+  templatesGetCommand,
+  flowsListCommand,
+  flowsGetCommand,
   integrationsListCommand,
   chatsGetCommand,
   healthCommand,
@@ -5593,7 +6658,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",
@@ -5607,15 +6673,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: