@zanfia/cli 0.21.0 → 0.23.0

package/dist/index.js

@@ -6901,7 +6901,7 @@ var {
 } = import_index.default;
 
 // src/program.ts
-import { readFileSync as readFileSync28 } from "fs";
+import { readFileSync as readFileSync29 } from "fs";
 
 // src/utils/config.ts
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
@@ -8011,6 +8011,15 @@ function createMockClient() {
     async retryAutomationRun() {
       throw new ApiError(501, "workflows are not available in mock mode");
     },
+    async stopAutomationRun() {
+      throw new ApiError(501, "workflows are not available in mock mode");
+    },
+    async listClientAutomationRuns() {
+      return { items: [] };
+    },
+    async stopClientAutomationRuns() {
+      throw new ApiError(501, "workflows are not available in mock mode");
+    },
     async testRunAutomation() {
       throw new ApiError(501, "workflows are not available in mock mode");
     },
@@ -8648,6 +8657,30 @@ function createMockClient() {
     async rejectManualOrder() {
       throw new ApiError(501, "manual order decisions are not available in mock mode");
     },
+    async markOrderAsTest() {
+      throw new ApiError(501, "order changes are not available in mock mode");
+    },
+    async markOrderRefunded() {
+      throw new ApiError(501, "order changes are not available in mock mode");
+    },
+    async listConsultationBookings() {
+      return { items: [], nextCursor: null, from: "", to: "" };
+    },
+    async listConsultationClientsWithoutBooking() {
+      return { items: [], nextCursor: null };
+    },
+    async listCourseQuestions() {
+      return { questions: [], nextCursor: null };
+    },
+    async replyToCourseQuestion() {
+      throw new ApiError(501, "lesson Q&A is not available in mock mode");
+    },
+    async setCourseQuestionStatus() {
+      throw new ApiError(501, "lesson Q&A is not available in mock mode");
+    },
+    async acceptCourseAnswer() {
+      throw new ApiError(501, "lesson Q&A is not available in mock mode");
+    },
     async listFailedSubscriptionPayments() {
       return { items: [], stripeConnected: false };
     },
@@ -8852,6 +8885,21 @@ function createMockClient() {
     async listCommunityEventAttendees() {
       throw new ApiError(501, "community events are not available in mock mode");
     },
+    async listCommunityJoinRequests() {
+      return { requests: [], pendingCount: 0 };
+    },
+    async approveCommunityJoinRequests() {
+      throw new ApiError(501, "community join requests are not available in mock mode");
+    },
+    async declineCommunityJoinRequests() {
+      throw new ApiError(501, "community join requests are not available in mock mode");
+    },
+    async listCommunityDigestDrafts() {
+      return { digestEnabled: false, current: null, history: [] };
+    },
+    async decideCommunityDigestDraft() {
+      throw new ApiError(501, "the community digest is not available in mock mode");
+    },
     async getCommunityModerationQueue() {
       return { pending: [], resolved: [] };
     },
@@ -8924,6 +8972,24 @@ function createMockClient() {
     async getLiveRoomAttendance() {
       throw new ApiError(501, "webinars are not available in mock mode");
     },
+    async createExternalWebinar() {
+      throw new ApiError(501, "webinars are not available in mock mode");
+    },
+    async setLiveRoomReplay() {
+      throw new ApiError(501, "webinars are not available in mock mode");
+    },
+    async setLiveRoomStudioScene() {
+      throw new ApiError(501, "webinars are not available in mock mode");
+    },
+    async createLiveRoomStudioGuestInvite() {
+      throw new ApiError(501, "webinars are not available in mock mode");
+    },
+    async listLiveRoomStudioGuests() {
+      throw new ApiError(501, "webinars are not available in mock mode");
+    },
+    async revokeLiveRoomStudioGuestInvite() {
+      throw new ApiError(501, "webinars are not available in mock mode");
+    },
     async call(method, pathTemplate) {
       throw new ApiError(501, `${method} ${pathTemplate} is not available in mock mode`);
     },
@@ -8984,6 +9050,15 @@ function createMockClient() {
     async createMetaAd() {
       throw new ApiError(501, "Meta Ads are not available in mock mode");
     },
+    async createMetaCampaign() {
+      throw new ApiError(501, "Meta Ads are not available in mock mode");
+    },
+    async createMetaAdSet() {
+      throw new ApiError(501, "Meta Ads are not available in mock mode");
+    },
+    async createMetaAdFromScratch() {
+      throw new ApiError(501, "Meta Ads are not available in mock mode");
+    },
     async updateMetaAd() {
       throw new ApiError(501, "Meta Ads are not available in mock mode");
     },
@@ -9014,6 +9089,9 @@ function createMockClient() {
     async generateFunnelStepPage() {
       throw new ApiError(501, "funnels are not available in mock mode");
     },
+    async addFunnelOfferPage() {
+      throw new ApiError(501, "funnels are not available in mock mode");
+    },
     async listFunnelTemplates() {
       return { templates: [] };
     },
@@ -9092,6 +9170,66 @@ function createMockClient() {
     async updateSiteLegalDocuments() {
       throw new ApiError(501, "legal documents are not available in mock mode");
     },
+    async listLibrarySections() {
+      return { sections: [], unassignedProducts: [] };
+    },
+    async replaceLibrarySections() {
+      throw new ApiError(501, "library sections are not available in mock mode");
+    },
+    async createLibrarySection() {
+      throw new ApiError(501, "library sections are not available in mock mode");
+    },
+    async reorderLibrarySections() {
+      throw new ApiError(501, "library sections are not available in mock mode");
+    },
+    async moveLibraryProducts() {
+      throw new ApiError(501, "library sections are not available in mock mode");
+    },
+    async renameLibrarySection() {
+      throw new ApiError(501, "library sections are not available in mock mode");
+    },
+    async deleteLibrarySection() {
+      throw new ApiError(501, "library sections are not available in mock mode");
+    },
+    async listStudioSocialDrafts() {
+      throw new ApiError(501, "Studio drafts are not available in mock mode");
+    },
+    async generateStudioSocialDrafts() {
+      throw new ApiError(501, "Studio drafts are not available in mock mode");
+    },
+    async sendStudioSocialDraftFeedback() {
+      throw new ApiError(501, "Studio drafts are not available in mock mode");
+    },
+    async sendStudioSocialDraftToComposer() {
+      throw new ApiError(501, "Studio drafts are not available in mock mode");
+    },
+    async getSocialWeekReport() {
+      throw new ApiError(501, "social insights are not available in mock mode");
+    },
+    async getSocialPostPerformance() {
+      throw new ApiError(501, "social insights are not available in mock mode");
+    },
+    async setYouTubeVideoVisibility() {
+      throw new ApiError(501, "YouTube visibility is not available in mock mode");
+    },
+    async notifyCheckoutWaitlist() {
+      throw new ApiError(501, "the offer waiting list is not available in mock mode");
+    },
+    async duplicateProduct() {
+      throw new ApiError(501, "product duplicate is not available in mock mode");
+    },
+    async getSenderDomainWarmups() {
+      return { warmups: [] };
+    },
+    async declareSenderDomainWarmed() {
+      throw new ApiError(501, "domain warm-up is not available in mock mode");
+    },
+    async deleteClientEmailDrafts() {
+      throw new ApiError(501, "client e-mails are not available in mock mode");
+    },
+    async resendFormSubmissionRoomLink() {
+      throw new ApiError(501, "form submissions are not available in mock mode");
+    },
     async listClientDevices() {
       throw new ApiError(501, "client devices are not available in mock mode");
     },
@@ -9387,11 +9525,20 @@ function createHttpClient(config) {
       "GET",
       `/automations/${encodeURIComponent(id)}/runs${limit !== void 0 ? `?limit=${limit}` : ""}`
     ),
-    setAutomationStatus: (id, status) => request("POST", `/automations/${encodeURIComponent(id)}/status`, { status }),
+    setAutomationStatus: (id, status, heldEvents) => request("POST", `/automations/${encodeURIComponent(id)}/status`, {
+      status,
+      ...heldEvents ? { heldEvents } : {}
+    }),
     retryAutomationRun: (automationId, runId) => request(
       "POST",
       `/automations/${encodeURIComponent(automationId)}/runs/${encodeURIComponent(runId)}/retry`
     ),
+    stopAutomationRun: (automationId, runId) => request(
+      "POST",
+      `/automations/${encodeURIComponent(automationId)}/runs/${encodeURIComponent(runId)}/stop`
+    ),
+    listClientAutomationRuns: (clientId) => request("GET", `/clients/${encodeURIComponent(clientId)}/automation-runs`),
+    stopClientAutomationRuns: (clientId) => request("POST", `/clients/${encodeURIComponent(clientId)}/automation-runs/stop`),
     testRunAutomation: (automationId, input) => request("POST", `/automations/${encodeURIComponent(automationId)}/test-run`, input),
     getCourseContent: (productId) => request("GET", `/products/${encodeURIComponent(productId)}/course`),
     getCourseAnalytics: (productId, options) => {
@@ -9833,7 +9980,11 @@ function createHttpClient(config) {
     createAudienceSegment: (input) => request("POST", "/segments", input),
     updateAudienceSegment: (id, input) => request("PATCH", `/segments/${encodeURIComponent(id)}`, input),
     deleteAudienceSegment: (id) => request("DELETE", `/segments/${encodeURIComponent(id)}`),
-    previewAudienceSegment: (conditions) => request("POST", "/segments/preview", { conditions }),
+    previewAudienceSegment: (conditions, options = {}) => request("POST", "/segments/preview", {
+      conditions,
+      ...options.requireSendable ? { requireSendable: true } : {},
+      ...options.requireSmsSendable ? { requireSmsSendable: true } : {}
+    }),
     importClients: (input) => request("POST", "/clients/import", input),
     getClientMergePreview: (survivorClientId, duplicateClientId) => {
       const params = new URLSearchParams();
@@ -9863,6 +10014,29 @@ function createHttpClient(config) {
     // Manual (wire-transfer) order decisions.
     approveManualOrder: (orderId, input) => request("POST", `/orders/${encodeURIComponent(orderId)}/approve-payment`, input),
     rejectManualOrder: (orderId) => request("POST", `/orders/${encodeURIComponent(orderId)}/reject-payment`),
+    markOrderAsTest: (orderId, isTest) => request("POST", `/orders/${encodeURIComponent(orderId)}/mark-test`, { isTest }),
+    markOrderRefunded: (orderId, input) => request("POST", `/orders/${encodeURIComponent(orderId)}/mark-refunded`, input),
+    listConsultationBookings: (options) => request("GET", `/consultations/bookings${toQuery(options)}`),
+    listConsultationClientsWithoutBooking: (options) => request("GET", `/consultations/clients-without-booking${toQuery(options)}`),
+    listCourseQuestions: (productId, options) => request(
+      "GET",
+      `/products/${encodeURIComponent(productId)}/course/questions${toQuery(options)}`
+    ),
+    replyToCourseQuestion: (productId, questionId, content) => request(
+      "POST",
+      `/products/${encodeURIComponent(productId)}/course/questions/${encodeURIComponent(questionId)}/replies`,
+      { content }
+    ),
+    setCourseQuestionStatus: (productId, entryId, status) => request(
+      "PATCH",
+      `/products/${encodeURIComponent(productId)}/course/questions/${encodeURIComponent(entryId)}`,
+      { status }
+    ),
+    acceptCourseAnswer: (productId, questionId, replyId) => request(
+      "POST",
+      `/products/${encodeURIComponent(productId)}/course/questions/${encodeURIComponent(questionId)}/accept`,
+      { replyId }
+    ),
     // Subscriptions: failed payments, manual renewals, ending soon.
     listFailedSubscriptionPayments: () => request("GET", "/subscriptions/failed-payments"),
     retrySubscriptionPayment: (invoiceId) => request("POST", `/subscriptions/failed-payments/${encodeURIComponent(invoiceId)}/retry`),
@@ -10089,6 +10263,23 @@ function createHttpClient(config) {
       "GET",
       `/v1/communities/${encodeURIComponent(communityId)}/events/${encodeURIComponent(eventId)}/attendees`
     ),
+    listCommunityJoinRequests: (communityId) => communityRequest("GET", `/v1/communities/${encodeURIComponent(communityId)}/join-requests`),
+    approveCommunityJoinRequests: (communityId, requestIds) => communityRequest(
+      "POST",
+      `/v1/communities/${encodeURIComponent(communityId)}/join-requests/approve`,
+      { requestIds }
+    ),
+    declineCommunityJoinRequests: (communityId, requestIds) => communityRequest(
+      "POST",
+      `/v1/communities/${encodeURIComponent(communityId)}/join-requests/decline`,
+      { requestIds }
+    ),
+    listCommunityDigestDrafts: (communityId) => communityRequest("GET", `/v1/communities/${encodeURIComponent(communityId)}/digest-drafts`),
+    decideCommunityDigestDraft: (communityId, input) => communityRequest(
+      "POST",
+      `/v1/communities/${encodeURIComponent(communityId)}/digest-drafts/decide`,
+      input
+    ),
     getCommunityModerationQueue: (communityId) => communityRequest(
       "GET",
       `/v1/communities/${encodeURIComponent(communityId)}/moderation/reports`
@@ -10141,8 +10332,17 @@ function createHttpClient(config) {
       "GET",
       `/forms/${encodeURIComponent(id)}/submissions${limit !== void 0 ? `?limit=${limit}` : ""}`
     ),
-    // Live rooms live on the Workspace API (api-v1), read only.
+    // Live rooms live on the Workspace API (api-v1): reads, the external webinar and its replay.
     listLiveRooms: () => request("GET", "/live-rooms"),
+    createExternalWebinar: (input) => request("POST", "/live-rooms", input),
+    setLiveRoomReplay: (roomId, mediaId) => request("PUT", `/live-rooms/${encodeURIComponent(roomId)}/replay`, { mediaId }),
+    setLiveRoomStudioScene: (roomId, input) => request("POST", `/live-rooms/${encodeURIComponent(roomId)}/studio/scene`, input),
+    createLiveRoomStudioGuestInvite: (roomId, input) => request("POST", `/live-rooms/${encodeURIComponent(roomId)}/studio/guests`, input),
+    listLiveRoomStudioGuests: (roomId) => request("GET", `/live-rooms/${encodeURIComponent(roomId)}/studio/guests`),
+    revokeLiveRoomStudioGuestInvite: (roomId, guestId) => request(
+      "DELETE",
+      `/live-rooms/${encodeURIComponent(roomId)}/studio/guests/${encodeURIComponent(guestId)}`
+    ),
     getLiveRoomAttendance: (roomId, session) => request(
       "GET",
       `/live-rooms/${encodeURIComponent(roomId)}/attendance${session !== void 0 ? `?session=${encodeURIComponent(session)}` : ""}`
@@ -10181,6 +10381,9 @@ function createHttpClient(config) {
     updateMetaAdSet: (scope, adSetId, input) => request("PATCH", `${metaAdAccountPath(scope)}/ad-sets/${encodeURIComponent(adSetId)}`, input),
     listMetaAds: (scope, query) => request("GET", `${metaAdAccountPath(scope)}/ads${toQuery(query)}`),
     createMetaAd: (scope, input) => request("POST", `${metaAdAccountPath(scope)}/ads`, input),
+    createMetaCampaign: (scope, input) => request("POST", `${metaAdAccountPath(scope)}/campaigns`, input),
+    createMetaAdSet: (scope, input) => request("POST", `${metaAdAccountPath(scope)}/ad-sets`, input),
+    createMetaAdFromScratch: (scope, input) => request("POST", `${metaAdAccountPath(scope)}/ads/from-scratch`, input),
     updateMetaAd: (scope, adId, input) => request("PATCH", `${metaAdAccountPath(scope)}/ads/${encodeURIComponent(adId)}`, input),
     getMetaAdCreative: (scope, adId) => request("GET", `${metaAdAccountPath(scope)}/ads/${encodeURIComponent(adId)}/creative`),
     updateMetaAdCreative: (scope, adId, input) => request(
@@ -10196,6 +10399,7 @@ function createHttpClient(config) {
     updateFunnel: (id, input) => request("PATCH", `/funnels/${encodeURIComponent(id)}`, input),
     deleteFunnel: (id) => request("DELETE", `/funnels/${encodeURIComponent(id)}`),
     generateFunnelStepPage: (id, input) => request("POST", `/funnels/${encodeURIComponent(id)}/generate-step-page`, input),
+    addFunnelOfferPage: (id, input) => request("POST", `/funnels/${encodeURIComponent(id)}/offer-page`, input),
     listFunnelTemplates: () => request("GET", "/funnel-templates"),
     createFunnelFromTemplate: (input) => request("POST", "/funnels/from-template", input),
     createFunnelFromPages: (input) => request("POST", "/funnels/from-pages", input),
@@ -10227,6 +10431,36 @@ function createHttpClient(config) {
       language ? `/site/legal-documents?language=${encodeURIComponent(language)}` : "/site/legal-documents"
     ),
     updateSiteLegalDocuments: (input) => request("PATCH", "/site/legal-documents", input),
+    listLibrarySections: () => request("GET", "/site/library-sections"),
+    replaceLibrarySections: (sections) => request("PUT", "/site/library-sections", { sections }),
+    createLibrarySection: (input) => request("POST", "/site/library-sections", input),
+    reorderLibrarySections: (sectionIds) => request("POST", "/site/library-sections/reorder", { sectionIds }),
+    moveLibraryProducts: (productIds, sectionId) => request("POST", "/site/library-sections/move-products", { productIds, sectionId }),
+    renameLibrarySection: (sectionId, name) => request("PATCH", `/site/library-sections/${encodeURIComponent(sectionId)}`, { name }),
+    deleteLibrarySection: (sectionId) => request("DELETE", `/site/library-sections/${encodeURIComponent(sectionId)}`),
+    // Studio weekly drafts + post insights (`social-token` routes on api-v1).
+    listStudioSocialDrafts: () => request("GET", "/studio/social-drafts"),
+    generateStudioSocialDrafts: (input) => request("POST", "/studio/social-drafts/generate", input),
+    sendStudioSocialDraftFeedback: (draftId, reason) => request("POST", `/studio/social-drafts/${encodeURIComponent(draftId)}/feedback`, {
+      reason
+    }),
+    sendStudioSocialDraftToComposer: (draftId, input) => request("POST", `/studio/social-drafts/${encodeURIComponent(draftId)}/to-composer`, input),
+    getSocialWeekReport: () => request("GET", "/social/reports/weekly"),
+    getSocialPostPerformance: (postId) => request("GET", `/social/posts/${encodeURIComponent(postId)}/performance`),
+    setYouTubeVideoVisibility: (postId, input) => request("POST", `/social/posts/${encodeURIComponent(postId)}/youtube-visibility`, input),
+    notifyCheckoutWaitlist: (checkoutId, dryRun) => request("POST", `/checkouts/${encodeURIComponent(checkoutId)}/notify-waitlist`, { dryRun }),
+    duplicateProduct: (productId, name) => request(
+      "POST",
+      `/products/${encodeURIComponent(productId)}/duplicate`,
+      name !== void 0 ? { name } : {}
+    ),
+    getSenderDomainWarmups: () => request("GET", "/sender-domain/warmups"),
+    declareSenderDomainWarmed: (domain) => request("POST", `/sender-domain/${encodeURIComponent(domain)}/warmup-declarations`),
+    deleteClientEmailDrafts: (input) => request("POST", "/client-emails/delete-drafts", input),
+    resendFormSubmissionRoomLink: (formId, submissionId) => request(
+      "POST",
+      `/forms/${encodeURIComponent(formId)}/submissions/${encodeURIComponent(submissionId)}/room-link`
+    ),
     // Customer access devices (anti-sharing device slots) — Workspace API.
     listClientDevices: (clientId) => request("GET", `/clients/${encodeURIComponent(clientId)}/devices`),
     revokeClientDevice: (clientId, deviceId) => request(
@@ -10949,7 +11183,7 @@ function registerBlogCommands(program2) {
     "Schedules a DRAFT (or reschedules a scheduled post) to be published at `scheduledAt`: status `scheduled`, not public anywhere (list, feed, sitemap, its URL) until then, then published exactly like publish-blog-post. Needs a non-empty body (400); a published post answers 409 (unpublish it first). `scheduledAt: null` unschedules (back to draft); publishing it now is publish-blog-post. Returns the full post with `scheduledAt`."
   ).argument("<id>", "Blog post id (`post_\u2026`) from list-blog-posts.").requiredOption(
     "--at <value>",
-    `When the post goes live: an ISO 8601 date-time WITH the offset of the creator's time zone, Europe/Warsaw = +01:00 in winter (CET), +02:00 in summer (CEST), e.g. "poniedzia\u0142ek 8:00" in late October = 2026-10-26T08:00:00+01:00. At least a minute and at most a year ahead. null = unschedule (back to draft).`
+    'When the post goes live: Polish time without an offset ("2026-10-26T08:00", read in Europe/Warsaw with the offset of that date, also across a clock change) or an ISO 8601 date-time with an offset / Z (2026-10-26T08:00:00+01:00). At least a minute and at most a year ahead. null = unschedule (back to draft).'
   ).action(async (id, options, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
@@ -11338,6 +11572,289 @@ function registerPopupsCommands(program2) {
   });
 }
 
+// src/commands/_generated/products.ts
+var listProductBuyersNotificationsColumns = [
+  "id",
+  "title",
+  "status",
+  "createdAt",
+  "confirmedRecipientCount"
+];
+function registerProductsCommands(program2) {
+  const products2 = program2.commands.find((command) => command.name() === "products") ?? program2.command("products");
+  if (!products2.description()) {
+    products2.description(
+      "A product's buyer notifications (\u201EPowiadom kupuj\u0105cych\u201D): list, preview, send"
+    );
+  }
+  const productsNotifications = products2.command("notifications");
+  productsNotifications.description(
+    "A product's buyer notifications (\u201EPowiadom kupuj\u0105cych\u201D): list, preview, send"
+  );
+  productsNotifications.command("preview").summary("Preview a notification to a product's buyers").description(
+    "Step 1 of \u201EPowiadom kupuj\u0105cych\u201D: how many people a push + portal bell (+ optional e-mail) to everyone with access to ONE product would reach right now, and whether a limit stops it (one send per product per hour, a daily cap per workspace; only a published product). Sends nothing. Show the count to the human and get an explicit yes before notify-product-buyers. Also checks the optional link (own platform only)."
+  ).argument("<productId>", "Product id (`prod_\u2026`) from list-products.").option(
+    "--link <value>",
+    "Optional link the notification opens: a page of the creator's OWN platform, as a path (`/app/courses/{slug}?lesson={lessonId}`) or a URL on the platform domain. Any other host is refused (400 invalid_link). Empty = the product page."
+  ).option(
+    "--send-email",
+    "The e-mail would be ticked: also check the monthly e-mail allowance (`emailSkipped`)."
+  ).option("--no-send-email", "Send `sendEmail: false` explicitly.").action(
+    async (productId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const params = {
+        productId
+      };
+      const payload = {
+        link: options.link,
+        sendEmail: options.sendEmail
+      };
+      const result = await client.call(
+        "POST",
+        "/products/:productId/buyers-notifications/preview",
+        params,
+        void 0,
+        payload
+      );
+      emit(flags, result ?? {}, () => printJson(result ?? {}));
+    }
+  );
+  productsNotifications.command("send").summary("Notify a product's buyers").description(
+    "Step 2 of \u201EPowiadom kupuj\u0105cych\u201D: sends a short message (title + up to 200 characters + an optional link on the own platform) to everyone with access to ONE product right now: a push in the mobile app, a bell item on the portal and, with `sendEmail`, an e-mail. HIGHEST-STAKES ACTION: call preview-product-buyers-notification first, tell the human the recipient count and send only after an explicit yes, passing that count as `confirmedRecipientCount`. Limits: one send per product per hour, a daily cap per workspace (429). The delivery runs in the background: list-product-buyers-notifications shows the counts a little later. It cannot be recalled."
+  ).argument("<productId>", "Product id (`prod_\u2026`) from list-products.").requiredOption(
+    "--title <value>",
+    "The notification title (push title, bell line, e-mail subject). One line."
+  ).requiredOption("--body <value>", "The message, up to 200 characters.").option(
+    "--link <value>",
+    "Optional link the notification opens: a page of the creator's OWN platform, as a path (`/app/courses/{slug}?lesson={lessonId}`) or a URL on the platform domain. Any other host is refused (400 invalid_link). Empty = the product page."
+  ).option(
+    "--send-email",
+    "Also send it as an e-mail (clients who unsubscribed are skipped). Default: no.",
+    false
+  ).requiredOption(
+    "--confirmed-recipient-count <n>",
+    "The `recipientCount` from preview-product-buyers-notification that the human confirmed. More people with access now = refused (409 recipient_count_changed): preview again.",
+    parseNumberOption("--confirmed-recipient-count", NumberFormat.Integer)
+  ).option(
+    "--send-id <value>",
+    "Idempotency key (8-64 of A-Z a-z 0-9 _ -): a retried call with the same id returns the first send instead of sending again. Generated when omitted."
+  ).option(
+    "--confirm",
+    "required \u2014 acknowledge that you want to notify every buyer of this product now (it cannot be recalled)"
+  ).action(async (productId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(
+      options.confirm,
+      "notify every buyer of this product now (it cannot be recalled)"
+    );
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {
+      productId
+    };
+    const payload = {
+      title: options.title,
+      body: options.body,
+      link: options.link,
+      sendEmail: options.sendEmail,
+      confirmedRecipientCount: options.confirmedRecipientCount,
+      sendId: options.sendId
+    };
+    const result = await client.call(
+      "POST",
+      "/products/:productId/buyers-notifications",
+      params,
+      void 0,
+      payload
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  productsNotifications.command("list").summary("List a product's buyer notifications").description(
+    "The send log of \u201EPowiadom kupuj\u0105cych\u201D for ONE product, newest first: date, text, link, status and what was delivered (recipients, bells, pushes, e-mails, opted out)."
+  ).argument("<productId>", "Product id (`prod_\u2026`) from list-products.").option(
+    "--limit <n>",
+    "Newest first; default 20, max 50.",
+    parseNumberOption("--limit", NumberFormat.Integer)
+  ).action(
+    async (productId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const params = {
+        productId
+      };
+      const payload = {
+        limit: options.limit
+      };
+      const result = await client.call(
+        "GET",
+        "/products/:productId/buyers-notifications",
+        params,
+        payload,
+        void 0
+      );
+      const rows = tableRowsOf(result, "items");
+      emit(flags, result ?? {}, () => printTable(rows, listProductBuyersNotificationsColumns));
+    }
+  );
+  const productsStock = products2.command("stock", { hidden: true });
+  productsStock.description("A physical product's stock per variant");
+  productsStock.command("get", { hidden: true }).summary("Read a physical product's stock").description(
+    "\u201EWarianty i stan magazynowy\u201D of ONE physical product: per variant (a price of the product's default offer) its stock (the total that may ever sell; null = no limit), the units sold, the units reserved by unpaid orders, what is still available and whether it is personalised. 400 for a digital product, 409 when the product has no offer yet. Read-only."
+  ).argument("<productId>", "The physical product id (`prod_\u2026` from list-products).").action(async (productId, _options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {
+      productId
+    };
+    const result = await client.call(
+      "GET",
+      "/products/:productId/stock",
+      params,
+      void 0,
+      void 0
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  productsStock.command("set", { hidden: true }).summary("Set a physical product's stock").description(
+    "Sets the stock of a physical product's variants, like saving \u201EWarianty i stan magazynowy\u201D: each listed price of the product's default offer is saved with only its stock (`quantityLimit`) changed; label, amount and every other setting stay. `stock` is the TOTAL that may ever sell (sold and reserved units count against it); null = no limit; 0 is refused (Zanfia reads 0 as no limit). Returns the stock after the save. Reversible: set it again."
+  ).argument("<productId>", "The physical product id (`prod_\u2026` from list-products).").requiredOption(
+    "--variants <json|file>",
+    "Only the variants listed change; the rest keep their stock.",
+    parseJsonArrayFileOrInline("--variants")
+  ).option("--confirm", "required \u2014 acknowledge that you want to change this product's stock").action(async (productId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, "change this product's stock");
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {
+      productId
+    };
+    const payload = {
+      variants: options.variants
+    };
+    const result = await client.call(
+      "PATCH",
+      "/products/:productId/stock",
+      params,
+      void 0,
+      payload
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+}
+
+// src/commands/_generated/subscriptions.ts
+var listInstallmentArrearsColumns = [
+  "productName",
+  "clientEmail",
+  "subscriptionStatus",
+  "installmentsPaid",
+  "installmentsTotal",
+  "overdueAmountMinor",
+  "currency"
+];
+function registerSubscriptionsCommands(program2) {
+  const subscriptions = program2.commands.find((command) => command.name() === "subscriptions") ?? program2.command("subscriptions");
+  if (!subscriptions.description()) {
+    subscriptions.description(
+      "Instalment arrears (\u201EZaleg\u0142o\u015Bci w ratach\u201D) and the non-payment setting"
+    );
+  }
+  const subscriptionsArrears = subscriptions.command("arrears");
+  subscriptionsArrears.description(
+    "Instalment arrears (\u201EZaleg\u0142o\u015Bci w ratach\u201D) and the non-payment setting"
+  );
+  subscriptionsArrears.command("setting").summary("What happens when a buyer stops paying instalments").description(
+    "The workspace's choice for an instalment plan Stripe ends before its last instalment (a non-payment): `revoke` ends the access like a plain subscription end, `keep` leaves it and lists the buyer on \u201EZaleg\u0142o\u015Bci\u201D. Default `revoke`. It applies to plans bought since the setting shipped; older plans always keep their access (they show on \u201EZaleg\u0142o\u015Bci\u201D). A plan paid in full is never affected."
+  ).action(async (_options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const result = await client.call(
+      "GET",
+      "/settings/installment-non-payment",
+      params,
+      void 0,
+      void 0
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  subscriptionsArrears.command("set-setting").summary("Change what happens when a buyer stops paying instalments").description(
+    "Saves the workspace's choice: `revoke` (end the access like a plain subscription end) or `keep` (leave it, list the buyer on \u201EZaleg\u0142o\u015Bci\u201D). It applies the next time Stripe ends an unfinished plan bought since the setting shipped; no access changes now, and plans from before it always keep their access. Answers the setting as saved."
+  ).addOption(
+    new Option(
+      "--action <revoke|keep>",
+      "`revoke` = end the access like a plain subscription end (same e-mails, community / Discord removal); `keep` = leave the access and list the buyer on \u201EZaleg\u0142o\u015Bci\u201D."
+    ).choices(["revoke", "keep"]).makeOptionMandatory()
+  ).option(
+    "--confirm",
+    "required \u2014 acknowledge that you want to change what happens to every buyer who stops paying instalments"
+  ).action(async (options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(
+      options.confirm,
+      "change what happens to every buyer who stops paying instalments"
+    );
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const payload = {
+      action: options.action
+    };
+    const result = await client.call(
+      "PATCH",
+      "/settings/installment-non-payment",
+      params,
+      void 0,
+      payload
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  subscriptionsArrears.command("list").summary("List buyers behind on instalments (\u201EZaleg\u0142o\u015Bci\u201D)").description(
+    "Every buyer whose unfinished instalment plan stopped being paid (Stripe past_due / unpaid / canceled), checked live in Stripe first; a buyer who paid outside Stripe (Stripe \u201Emark as paid\u201D, an approved transfer order, a recorded offline payment) is not listed. Per row: what is overdue now and what was never billed (minor units), since when, the instalments paid, whether the access was kept by the setting or because the plan predates it, and whether to check a Fakturownia proforma. Longest overdue first. Read-only."
+  ).option(
+    "--product-id <value>",
+    "One product (`prod_\u2026` from list-products); omitted = every product."
+  ).option(
+    "--include-kept",
+    "Also list the buyers the creator already chose \u201EZostaw\u201D for. Default false."
+  ).option("--no-include-kept", "Send `includeKept: false` explicitly.").action(async (options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const payload = {
+      productId: options.productId,
+      includeKept: options.includeKept
+    };
+    const result = await client.call("GET", "/installment-arrears", params, payload, void 0);
+    const rows = tableRowsOf(result, "items");
+    emit(flags, result ?? {}, () => printTable(rows, listInstallmentArrearsColumns));
+  });
+  subscriptionsArrears.command("keep").summary("Keep a behind-on-instalments buyer's access (\u201EZostaw\u201D)").description(
+    "\u201EZostaw\u201D on \u201EZaleg\u0142o\u015Bci\u201D: the creator keeps this buyer's access. Only a mark is saved (who, when): the access, Stripe and the buyer are not touched, and the row leaves the default list (`includeKept` shows it). 404 when the buyer is not on the list."
+  ).argument("<productId>", "The row's `productId`.").argument("<clientEmail>", "The row's `clientEmail`.").option(
+    "--confirm",
+    "required \u2014 acknowledge that you want to keep this buyer's access despite the unpaid instalments"
+  ).action(
+    async (productId, clientEmail, options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm(options.confirm, "keep this buyer's access despite the unpaid instalments");
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const params = {};
+      const payload = {
+        productId,
+        clientEmail
+      };
+      const result = await client.call(
+        "POST",
+        "/installment-arrears/keep",
+        params,
+        void 0,
+        payload
+      );
+      emit(flags, result ?? {}, () => printJson(result ?? {}));
+    }
+  );
+}
+
 // src/commands/_generated/studio.ts
 var suggestStudioVideoClipsColumns = ["startSeconds", "endSeconds", "hook"];
 function registerStudioCommands(program2) {
@@ -11596,35 +12113,195 @@ function registerSiteCommands(program2) {
       kind,
       pageId: options.page
     };
-    const result = await client.call("PUT", "/site/layout/template", params, void 0, payload);
+    const result = await client.call("PUT", "/site/layout/template", params, void 0, payload);
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  const siteMenu = site.command("menu");
+  siteMenu.description("The site's one shared menu (Your site \u2192 Look and menu): up to 8 entries");
+  siteMenu.command("get").summary("Get the shared site menu").description(
+    "The site's shared menu (dashboard: Your site \u2192 Look and menu \u2192 \u201EMenu witryny\u201D) in order: `label`, `style` (`link` / `button`), `target` (`page` + `pageId`, `blog`, `store`, `product` + `productId`, `login`, `url` + `url`) and `href`, the address it leads to today (null = nowhere now; pages leave it out). It fills every page that marks its menu with `data-zanfia-nav` and the blog in its page frame. Empty = every page keeps its own links. Edit it with set-site-menu (the whole list)."
+  ).action(async (_options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const result = await client.call("GET", "/site/menu", params, void 0, void 0);
+    const rows = tableRowsOf(result, "menu");
+    emit(flags, result ?? {}, () => printTable(rows, getSiteMenuColumns));
+  });
+  siteMenu.command("set").summary("Set the shared site menu").description(
+    'Replaces the site\'s shared menu with the entries sent, in order (up to 8; an entry left out is removed, an empty list turns the menu off). Live at once on every page that marks its menu with `data-zanfia-nav` and on the blog in its page frame. To add one entry (e.g. the blog: `{ label: "Blog", target: { kind: "blog" }, style: "link" }`) read get-site-menu first and send the whole list. Checked by the dashboard rules: 400 `site-menu-refused` with `issue` (`too-many-entries`, `empty-label`, `label-too-long`, `invalid-url`, `invalid-anchor`, `page-not-found`, `page-not-published`, `product-not-found`) and the entry `index`; nothing saved. Returns the whole layout.'
+  ).requiredOption(
+    "--menu <json|file>",
+    "EVERY entry of the new menu, in order (up to 8), as a JSON array; an empty list turns the shared menu off.",
+    parseJsonArrayFileOrInline("--menu")
+  ).action(async (options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const payload = {
+      menu: options.menu
+    };
+    const result = await client.call("PUT", "/site/menu", params, void 0, payload);
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+}
+
+// src/commands/_generated/chats.ts
+function registerChatsCommands(program2) {
+  const chats = program2.command("chats", { hidden: true });
+  chats.description("Czaty: the assistant and hired agents");
+  chats.command("list", { hidden: true }).summary("List chats with unread counts").description(
+    "The caller's chats (Czaty): the creator assistant's main conversation with its last line and unread count (messages it wrote first, e.g. the morning summary), the older assistant topics, and the hired desk agents (Copywriter, Analyst, Marketer, Finance) with their last line and unread reports. Agents only where the agents early access is on. Behind the early_access_chat_home launch flag (403 feature_not_available otherwise)."
+  ).action(async (_options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const result = await client.call("GET", "/chat-home", params, void 0, void 0);
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+}
+
+// src/commands/_generated/orders.ts
+function registerOrdersCommands(program2) {
+  const orders2 = program2.commands.find((command) => command.name() === "orders") ?? program2.command("orders", { hidden: true });
+  if (!orders2.description()) {
+    orders2.description("Physical orders to ship (\u201EDo wys\u0142ania\u201D): list, mark shipped / delivered");
+  }
+  const ordersFulfilment = orders2.command("fulfilment", { hidden: true });
+  ordersFulfilment.description(
+    "Physical orders to ship (\u201EDo wys\u0142ania\u201D): list, mark shipped / delivered"
+  );
+  ordersFulfilment.command("list", { hidden: true }).summary("List physical orders to ship (\u201EDo wys\u0142ania\u201D)").description(
+    "The \u201EDo wys\u0142ania\u201D queue of paid physical orders by shipping status, newest first, with what packing needs per row: the variant, quantity, personalisation, order bumps, the buyer, the delivery (InPost locker code or courier address, phone, parcel size), the shipping status with carrier and tracking number, the charged total, and the \u201ESprzedane ponad stan\u201D flag. `unfulfilledCount` is the badge. Test purchases are never listed. Read-only."
+  ).addOption(
+    new Option(
+      "--status <unfulfilled|shipped|delivered|returned|cancelled>",
+      "The tab: `unfulfilled` (\u201EDo wys\u0142ania\u201D, the default), `shipped` (\u201EWys\u0142ane\u201D), `delivered` (\u201EDor\u0119czone\u201D); also `returned` and `cancelled`."
+    ).choices(["unfulfilled", "shipped", "delivered", "returned", "cancelled"])
+  ).option("--cursor <value>", "`nextCursor` of the previous page; omit for the first page.").option(
+    "--limit <n>",
+    "Rows per page, newest first (default 50, max 200).",
+    parseNumberOption("--limit", NumberFormat.Integer)
+  ).action(async (options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {};
+    const payload = {
+      status: options.status,
+      cursor: options.cursor,
+      limit: options.limit
+    };
+    const result = await client.call("GET", "/orders/to-ship", params, payload, void 0);
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  ordersFulfilment.command("ship", { hidden: true }).summary("Mark a physical order as shipped").description(
+    "\u201EOznacz jako wys\u0142ane\u201D for ONE paid physical order: records the carrier, the tracking number and link and the shipping date, and by default e-mails the buyer \u201ETwoja paczka jest w drodze\u201D with the tracking link (once per tracking number; `notifyBuyer: false` records it without the e-mail). The first marking fires the order-shipped automations. Marking a shipped order again corrects the carrier or number and keeps the first shipping date. 409 for an unpaid, delivered, returned or cancelled order, 400 for a digital one. The e-mail cannot be recalled: confirm the order and the number first."
+  ).argument("<orderId>", "The order id (`orderId` from list-orders-to-ship or list-orders).").addOption(
+    new Option(
+      "--carrier <inpost|poczta_polska|dpd|dhl|gls|orlen_paczka|other>",
+      "inpost | poczta_polska | dpd | dhl | gls | orlen_paczka | other. InPost gets a tracking link built from the number; other carriers only with `trackingUrl`."
+    ).choices(["inpost", "poczta_polska", "dpd", "dhl", "gls", "orlen_paczka", "other"]).makeOptionMandatory()
+  ).option(
+    "--tracking-number <value>",
+    "The parcel number. Omit for a shipment without one (e.g. a letter)."
+  ).option(
+    "--tracking-url <value>",
+    "A tracking link (http/https). Omit for InPost: it is built from the number. Other carriers without one show the number only."
+  ).option(
+    "--notify-buyer",
+    "E-mail the buyer \u201ETwoja paczka jest w drodze\u201D with the tracking link (default true). Sent once per tracking number: re-marking with the same number sends nothing, a corrected number e-mails again."
+  ).option("--no-notify-buyer", "Send `notifyBuyer: false` explicitly.").option("--confirm", "required \u2014 acknowledge that you want to mark this order as shipped").action(async (orderId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, "mark this order as shipped");
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {
+      orderId
+    };
+    const payload = {
+      carrier: options.carrier,
+      trackingNumber: options.trackingNumber,
+      trackingUrl: options.trackingUrl,
+      notifyBuyer: options.notifyBuyer
+    };
+    const result = await client.call(
+      "POST",
+      "/orders/:orderId/mark-shipped",
+      params,
+      void 0,
+      payload
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
+  });
+  ordersFulfilment.command("deliver", { hidden: true }).summary("Mark a physical order as delivered").description(
+    "\u201EOznacz jako dor\u0119czone\u201D (also \u201Eodebrane\u201D for a personal pickup) for ONE paid physical order, from shipped or straight from unfulfilled (a hand delivery). Records the delivery date: the 14-day withdrawal period runs from it. No e-mail goes out. An already delivered order is returned unchanged. 409 for an unpaid, returned or cancelled order, 400 for a digital one."
+  ).argument("<orderId>", "The order id (`orderId` from list-orders-to-ship or list-orders).").option("--confirm", "required \u2014 acknowledge that you want to mark this order as delivered").action(async (orderId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, "mark this order as delivered");
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const params = {
+      orderId
+    };
+    const result = await client.call(
+      "POST",
+      "/orders/:orderId/mark-delivered",
+      params,
+      void 0,
+      void 0
+    );
     emit(flags, result ?? {}, () => printJson(result ?? {}));
   });
-  const siteMenu = site.command("menu");
-  siteMenu.description("The site's one shared menu (Your site \u2192 Look and menu): up to 8 entries");
-  siteMenu.command("get").summary("Get the shared site menu").description(
-    "The site's shared menu (dashboard: Your site \u2192 Look and menu \u2192 \u201EMenu witryny\u201D) in order: `label`, `style` (`link` / `button`), `target` (`page` + `pageId`, `blog`, `store`, `product` + `productId`, `login`, `url` + `url`) and `href`, the address it leads to today (null = nowhere now; pages leave it out). It fills every page that marks its menu with `data-zanfia-nav` and the blog in its page frame. Empty = every page keeps its own links. Edit it with set-site-menu (the whole list)."
+}
+
+// src/commands/_generated/tax.ts
+function registerTaxCommands(program2) {
+  const tax = program2.command("tax");
+  tax.description(
+    "Stripe Tax settings (on / off, inclusive / exclusive prices, EU companies pay net)"
+  );
+  tax.command("get").summary("Read the Stripe Tax settings").description(
+    "The workspace's Stripe Tax settings, as on Integracje \u2192 P\u0142atno\u015Bci \u2192 Stripe: whether Zanfia calculates tax with Stripe Tax (`enabled`), the default price mode while on (`behavior`: inclusive / exclusive), \u201EEU companies pay the net price\u201D (`euCompaniesPayNet`), and Stripe's own Tax state on the connected Stripe account (`accountStatus`, read live from Stripe). Read-only."
   ).action(async (_options, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
     const params = {};
-    const result = await client.call("GET", "/site/menu", params, void 0, void 0);
-    const rows = tableRowsOf(result, "menu");
-    emit(flags, result ?? {}, () => printTable(rows, getSiteMenuColumns));
+    const result = await client.call(
+      "GET",
+      "/integrations/payments/stripe/tax",
+      params,
+      void 0,
+      void 0
+    );
+    emit(flags, result ?? {}, () => printJson(result ?? {}));
   });
-  siteMenu.command("set").summary("Set the shared site menu").description(
-    'Replaces the site\'s shared menu with the entries sent, in order (up to 8; an entry left out is removed, an empty list turns the menu off). Live at once on every page that marks its menu with `data-zanfia-nav` and on the blog in its page frame. To add one entry (e.g. the blog: `{ label: "Blog", target: { kind: "blog" }, style: "link" }`) read get-site-menu first and send the whole list. Checked by the dashboard rules: 400 `site-menu-refused` with `issue` (`too-many-entries`, `empty-label`, `label-too-long`, `invalid-url`, `invalid-anchor`, `page-not-found`, `page-not-published`, `product-not-found`) and the entry `index`; nothing saved. Returns the whole layout.'
-  ).requiredOption(
-    "--menu <json|file>",
-    "EVERY entry of the new menu, in order (up to 8), as a JSON array; an empty list turns the shared menu off.",
-    parseJsonArrayFileOrInline("--menu")
-  ).action(async (options, command) => {
+  tax.command("set").summary("Change the Stripe Tax settings").description(
+    "Changes the workspace's Stripe Tax settings like the switches on Integracje \u2192 P\u0142atno\u015Bci \u2192 Stripe; only the fields sent change. Turning it on needs a connected Stripe account with Stripe Tax active in Stripe itself (409 `stripe_tax_not_active_on_account` otherwise, with the Stripe settings link) and sets the default mode to `inclusive` unless `behavior` is sent; turning it off is always allowed. `behavior` and `euCompaniesPayNet` exist only while it is on (409 `stripe_tax_off`). It applies to the next Stripe checkouts and to the next renewals of running subscriptions (turning it off stops tax on renewals; `euCompaniesPayNet` changes what EU-company subscribers pay at renewal); paid orders don't change. Answers the settings as saved. Reversible: change them again."
+  ).option(
+    "--enabled",
+    "true = turn Stripe Tax on (needs Stripe Tax active on the connected Stripe account; the default mode becomes `inclusive` unless `behavior` is sent too); false = turn it off (always allowed; clears the mode)."
+  ).option("--no-enabled", "Send `enabled: false` explicitly.").addOption(
+    new Option(
+      "--behavior <inclusive|exclusive>",
+      "The default price mode while on: `inclusive` (gross prices) or `exclusive` (net prices, tax added at checkout). Only while Stripe Tax is on."
+    ).choices(["inclusive", "exclusive"])
+  ).option(
+    "--eu-companies-pay-net",
+    "\u201EFirmy z UE p\u0142ac\u0105 cen\u0119 netto\u201D (KI#1720): a company from another EU country with a valid VAT number pays an inclusive price without the VAT. Only while Stripe Tax is on."
+  ).option("--no-eu-companies-pay-net", "Send `euCompaniesPayNet: false` explicitly.").action(async (options, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
     const params = {};
     const payload = {
-      menu: options.menu
+      enabled: options.enabled,
+      behavior: options.behavior,
+      euCompaniesPayNet: options.euCompaniesPayNet
     };
-    const result = await client.call("PUT", "/site/menu", params, void 0, payload);
+    const result = await client.call(
+      "PATCH",
+      "/integrations/payments/stripe/tax",
+      params,
+      void 0,
+      payload
+    );
     emit(flags, result ?? {}, () => printJson(result ?? {}));
   });
 }
@@ -11635,11 +12312,17 @@ function registerGeneratedCommands(program2) {
   registerBlogCommands(program2);
   registerSiteRedirectsCommands(program2);
   registerPopupsCommands(program2);
+  registerProductsCommands(program2);
+  registerSubscriptionsCommands(program2);
   registerStudioCommands(program2);
   registerSiteCommands(program2);
+  registerChatsCommands(program2);
+  registerOrdersCommands(program2);
+  registerTaxCommands(program2);
 }
 
 // src/commands/ads/index.ts
+import { randomUUID } from "crypto";
 import { readFileSync as readFileSync3 } from "fs";
 var SETTABLE_STATUSES = ["ACTIVE", "PAUSED"];
 var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
@@ -11738,6 +12421,74 @@ function parseUpdateCreativeInput(value) {
   }
   return parsed;
 }
+function parseCreateJson(value, allowed, required) {
+  const parsed = parseJsonObjectFileOrInline2(value, "--json");
+  const unknownKeys = Object.keys(parsed).filter((key) => !allowed.includes(key));
+  if (unknownKeys.length > 0) {
+    throw new Error(`--json accepts only ${allowed.join(", ")} (got: ${unknownKeys.join(", ")}).`);
+  }
+  const missing = required.filter((key) => parsed[key] === void 0);
+  if (missing.length > 0) {
+    throw new Error(`--json needs ${missing.join(", ")}.`);
+  }
+  return parsed;
+}
+var CREATE_CAMPAIGN_KEYS = [
+  "name",
+  "objective",
+  "specialAdCategories",
+  "dailyBudgetMinor",
+  "lifetimeBudgetMinor",
+  "endTime"
+];
+var CREATE_AD_SET_KEYS = [
+  "campaignId",
+  "name",
+  "dailyBudgetMinor",
+  "lifetimeBudgetMinor",
+  "startTime",
+  "endTime",
+  "targeting",
+  "publisherPlatforms",
+  "datasetId"
+];
+var CREATE_AD_FROM_SCRATCH_KEYS = [
+  "adSetId",
+  "name",
+  "pageId",
+  "instagramUserId",
+  "imageUrl",
+  "message",
+  "headline",
+  "description",
+  "callToActionType",
+  "link",
+  "urlTags"
+];
+function guardFieldsOf(options, what) {
+  if (!options.dryRun) requireConfirm2(options.confirm, what);
+  const idempotencyKey = options.idempotencyKey ?? randomUUID();
+  if (!options.idempotencyKey && !options.dryRun) {
+    process.stderr.write(
+      `Idempotency key: ${idempotencyKey} (re-run with --idempotency-key ${idempotencyKey} to retry safely)
+`
+    );
+  }
+  return { idempotencyKey, ...options.dryRun ? { dryRun: true } : {} };
+}
+function printCreatePreview(result, nextStep) {
+  const { preview: preview2 } = result;
+  const lead = result.dryRun ? "Dry run, nothing created." : result.replayed ? "Already created with this idempotency key (nothing new on Meta)." : "Created (PAUSED).";
+  process.stdout.write(`${lead}
+${preview2.summary}
+`);
+  process.stdout.write(
+    `Daily ceiling: ${formatMinor(preview2.ceiling.dailyCeilingMinor, preview2.budget.currency)}, used in the last 24 h: ${formatMinor(preview2.ceiling.usedLast24hMinor, preview2.budget.currency)}, left after this: ${formatMinor(preview2.ceiling.remainingAfterMinor, preview2.budget.currency)}.
+`
+  );
+  if (!result.dryRun) process.stdout.write(`${nextStep}
+`);
+}
 function requireConfirm2(confirm, what) {
   if (!confirm) {
     throw new Error(`Refusing to ${what} without --confirm. Re-run with --confirm to proceed.`);
@@ -12127,6 +12878,33 @@ Daily (${result.daily.length})
       });
     }
   );
+  campaign.command("create").description(
+    "Create a NEW campaign (OUTCOME_TRAFFIC | OUTCOME_SALES | OUTCOME_LEADS), always PAUSED. Optional DAILY campaign budget in minor units (a lifetime campaign budget is not supported yet: put lifetime budgets on the ad sets). Try --dry-run first; a real create requires --confirm."
+  ).argument(...CONNECTION_ARG).argument(...AD_ACCOUNT_ARG).requiredOption(
+    "--json <fileOrJson>",
+    `name, objective (required); specialAdCategories, dailyBudgetMinor (optional) ${JSON_FLAG_HINT}`
+  ).option("--dry-run", "preview only: what would be created, the budget and the ceiling left").option("--idempotency-key <key>", "repeat a key to retry safely (default: a new UUID)").option("--confirm", "required for a real create").action(
+    async (connectionId, adAccountId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const input = parseCreateJson(options.json, CREATE_CAMPAIGN_KEYS, [
+        "name",
+        "objective"
+      ]);
+      const guard = guardFieldsOf(options, `create campaign "${input.name}"`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.createMetaCampaign(scopeOf(connectionId, adAccountId), {
+        ...input,
+        ...guard
+      });
+      emit(flags, result, () => {
+        printCreatePreview(
+          result,
+          `Next: \`ads ad-set create ${connectionId} ${adAccountId} --json '{"campaignId":"${result.campaign?.id ?? "\u2026"}",\u2026}'\`.`
+        );
+        if (result.campaign) printCampaignTable([result.campaign]);
+      });
+    }
+  );
   ads.command("ad-sets").description("List ad sets of an ad account (budgets, schedule, effective status)").argument(...CONNECTION_ARG).argument(...AD_ACCOUNT_ARG).option("--campaign <campaignId>", "only ad sets of this campaign").option("--include-archived", "include ARCHIVED / DELETED ad sets").action(
     async (connectionId, adAccountId, options, command) => {
       const flags = getGlobalFlags(command);
@@ -12147,6 +12925,34 @@ Daily (${result.daily.length})
       emit(flags, result, () => printAdSet(result.adSet));
     }
   );
+  adSet.command("create").description(
+    "Create a NEW ad set under a campaign, always PAUSED: budget (when the campaign has none), schedule, targeting (countries, age, gender, audience ids), placements, pixel. Try --dry-run first; a real create requires --confirm."
+  ).argument(...CONNECTION_ARG).argument(...AD_ACCOUNT_ARG).requiredOption(
+    "--json <fileOrJson>",
+    `campaignId, name, targeting { countries, ageMin, ageMax, gender, customAudienceIds, excludedCustomAudienceIds, advantageAudience } (required: campaignId, name, targeting.countries); dailyBudgetMinor | lifetimeBudgetMinor + endTime, startTime, publisherPlatforms, datasetId ${JSON_FLAG_HINT}`
+  ).option("--dry-run", "preview only: what would be created, the budget and the ceiling left").option("--idempotency-key <key>", "repeat a key to retry safely (default: a new UUID)").option("--confirm", "required for a real create").action(
+    async (connectionId, adAccountId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const input = parseCreateJson(options.json, CREATE_AD_SET_KEYS, [
+        "campaignId",
+        "name",
+        "targeting"
+      ]);
+      const guard = guardFieldsOf(options, `create ad set "${input.name}"`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.createMetaAdSet(scopeOf(connectionId, adAccountId), {
+        ...input,
+        ...guard
+      });
+      emit(flags, result, () => {
+        printCreatePreview(
+          result,
+          `Next: \`ads create ${connectionId} ${adAccountId} --from-scratch --json '{"adSetId":"${result.adSet?.id ?? "\u2026"}",\u2026}'\`.`
+        );
+        if (result.adSet) printAdSet(result.adSet);
+      });
+    }
+  );
   adSet.command("update").description(
     "Change an ad set budget (minor units; daily XOR lifetime), schedule end or status \u2014 applies to every ad in the set. Requires --confirm."
   ).argument(...CONNECTION_ARG).argument(...AD_ACCOUNT_ARG).argument("<adSetId>", "ad set id (from `ads ad-sets`)").option("--daily-budget <minor>", "daily budget in minor units").option("--lifetime-budget <minor>", "lifetime budget in minor units (needs an end time)").option("--end-time <iso>", "schedule end, ISO 8601").option("--status <status>", `ad set status (${SETTABLE_STATUSES.join(" | ")})`).option("--confirm", "required \u2014 acknowledge the change on the live ad account").action(
@@ -12186,13 +12992,37 @@ More ads available \u2014 re-run with --after ${result.after}
     }
   );
   ads.command("create").description(
-    "Create an ad by duplicating an existing one (same ad set and page) with creative overrides from --json. The new ad is always created PAUSED. Requires --confirm."
+    "Create an ad, always PAUSED. Default: duplicate an existing ad (same ad set and page) with creative overrides from --json. --from-scratch: a new single-image ad in an ad set (image URL, Page, copy, link). Requires --confirm (not for --dry-run)."
   ).argument(...CONNECTION_ARG).argument(...AD_ACCOUNT_ARG).requiredOption(
     "--json <fileOrJson>",
-    `inline JSON object or .json path: sourceAdId, name (required); message, headline, description, callToActionType, link, imageUrl (optional) ${JSON_FLAG_HINT}`
-  ).option("--confirm", "required \u2014 acknowledge creating an ad on the live ad account").action(
+    `duplicate: sourceAdId, name (required); message, headline, description, callToActionType, link, imageUrl. --from-scratch: adSetId, name, pageId, imageUrl, message, link (required); instagramUserId, headline, description, callToActionType, urlTags ${JSON_FLAG_HINT}`
+  ).option("--from-scratch", "build a new ad instead of duplicating one (fr-0312)").option("--dry-run", "--from-scratch only: preview, nothing created").option("--idempotency-key <key>", "--from-scratch only: repeat a key to retry safely").option("--confirm", "required \u2014 acknowledge creating an ad on the live ad account").action(
     async (connectionId, adAccountId, options, command) => {
       const flags = getGlobalFlags(command);
+      if (options.fromScratch) {
+        const scratch = parseCreateJson(
+          options.json,
+          CREATE_AD_FROM_SCRATCH_KEYS,
+          ["adSetId", "name", "pageId", "imageUrl", "message", "link"]
+        );
+        const guard = guardFieldsOf(options, `create ad "${scratch.name}"`);
+        const scratchClient = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+        const created = await scratchClient.createMetaAdFromScratch(
+          scopeOf(connectionId, adAccountId),
+          { ...scratch, ...guard }
+        );
+        emit(flags, created, () => {
+          printCreatePreview(
+            created,
+            `Turn it on with \`ads update ${connectionId} ${adAccountId} ${created.ad?.id ?? "\u2026"} --status ACTIVE --confirm\` (it spends).`
+          );
+          if (created.ad) printAd(created.ad);
+        });
+        return;
+      }
+      if (options.dryRun || options.idempotencyKey) {
+        throw new Error("--dry-run and --idempotency-key apply to --from-scratch only.");
+      }
       const input = parseCreateAdInput(options.json);
       requireConfirm2(options.confirm, `create ad "${input.name}" from ${input.sourceAdId}`);
       const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
@@ -13091,6 +13921,8 @@ function promptHidden(question) {
 
 // src/commands/auth/register.ts
 var BOT_CHECK_FAILED_CODE = "auth/bot-check-failed";
+var DEVICE_VERIFICATION_REQUIRED_CODE = "auth/device-verification-required";
+var DEVICE_CONFIRMATION_NOTICE = "\nYour account is ready. Confirm this device in the Zanfia panel first:\nopening the panel in your browser; the CLI logs in once you are done.\n\n";
 var MAX_CODE_ATTEMPTS = 5;
 var MIN_PASSWORD_LENGTH = 8;
 var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -13250,12 +14082,22 @@ We sent a 6-digit code to ${email}. Check your inbox.
     codeChallengeMethod: "S256",
     hostname: safeHostname2()
   };
-  const minted = await postJson2(
-    "Authorizing CLI",
-    `${urls.usersUrl}/cli/auth/codes`,
-    codeBody,
-    { bearer: signIn.idToken, verbose }
-  );
+  let minted;
+  try {
+    minted = await postJson2(
+      "Authorizing CLI",
+      `${urls.usersUrl}/cli/auth/codes`,
+      codeBody,
+      { bearer: signIn.idToken, verbose }
+    );
+  } catch (error) {
+    if (error instanceof HttpJsonError && error.code === DEVICE_VERIFICATION_REQUIRED_CODE) {
+      process.stdout.write(DEVICE_CONFIRMATION_NOTICE);
+      await runLogin({ apiUrl: options.apiUrl, verbose });
+      return;
+    }
+    throw error;
+  }
   const exchangeBody = {
     code: minted.code,
     codeVerifier
@@ -13306,6 +14148,9 @@ plus its personal workspace are created.
 Running it with an email that already has a creator account simply signs
 that account in.
 
+When Zanfia asks you to confirm this device first, the CLI opens the panel in
+your browser; confirm the device there and the CLI logs in like \`login\`.
+
 Skipping the password is fine \u2014 you can always sign in with an emailed code.
 `
   ).action(async (options) => {
@@ -14311,6 +15156,7 @@ var GRANT_PAYMENT_METHODS = [
   "cash",
   "other"
 ];
+var HELD_EVENTS_DECISIONS = ["send", "skip"];
 var AIImageAspectRatio = /* @__PURE__ */ ((AIImageAspectRatio2) => {
   AIImageAspectRatio2["Square"] = "1:1";
   AIImageAspectRatio2["Portrait"] = "4:5";
@@ -14410,6 +15256,89 @@ var CLIENT_TAG_COLORS = [
   "purple"
 ];
 var TRANSCRIPTION_LANGUAGES = ["pl", "en", "default"];
+var COMMUNITY_JOIN_APPROVE_MAX_IDS = 20;
+var COMMUNITY_JOIN_DECLINE_MAX_IDS = 100;
+var LESSON_QA_INBOX_FILTERS = [
+  "unanswered",
+  "all",
+  "public",
+  "private",
+  "hidden"
+];
+var SETTABLE_LESSON_QA_ENTRY_STATUSES = [
+  "published",
+  "hidden"
+];
+var CONSULTATION_BOOKING_STATUSES = [
+  "booked",
+  "cancelled",
+  "done"
+];
+var STUDIO_SOCIAL_DRAFT_WEAK_REASONS = [
+  "too-generic",
+  "not-my-voice",
+  "too-long",
+  "too-salesy",
+  "sounds-like-ai",
+  "wrong-topic"
+];
+var YOUTUBE_PRIVACY_STATUSES = [
+  "private",
+  "unlisted",
+  "public"
+];
+
+// src/commands/clients/automationRuns.ts
+function stepLabel(run) {
+  const step = run.currentStep;
+  if (!step) return "";
+  return step.name ?? step.actionType ?? step.kind ?? step.nodeId;
+}
+function printStoppedRuns(result) {
+  process.stdout.write(
+    `Stopped ${result.stopped.length} run(s)${result.alreadyFinished > 0 ? `; ${result.alreadyFinished} had already finished` : ""}.
+`
+  );
+  for (const run of result.stopped) {
+    process.stdout.write(`  - run ${run.runId} (workflow ${run.automationId})
+`);
+  }
+}
+function registerClientAutomationRunsCommands(clients2) {
+  const runs = clients2.command("automation-runs").description(
+    "One customer's workflow runs in progress (the customer card \u2192 \u201EAutomatyzacje w toku\u201D): list them or take the customer out"
+  );
+  runs.command("list").description(
+    "Live runs of one customer across every workflow, newest first (test runs excluded)"
+  ).argument("<clientId>", "workspace client id (wcid)").action(async (clientId, _, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.listClientAutomationRuns(clientId);
+    emit(flags, result, () => {
+      printTable(
+        result.items.map((run) => ({
+          runId: run.runId,
+          workflow: run.automationName ?? `${run.automationId} (deleted)`,
+          workflowId: run.automationId,
+          status: run.status,
+          step: stepLabel(run),
+          nextStepAt: run.nextScheduledAt ?? "",
+          startedAt: run.startedAt
+        })),
+        ["runId", "workflow", "workflowId", "status", "step", "nextStepAt", "startedAt"]
+      );
+    });
+  });
+  runs.command("stop").description(
+    "Take the customer out of EVERY workflow run in progress \u2014 each run ends cancelled and no further step runs (a step already sending finishes). They can enter again when a trigger fires later. To stop one run: `workflows runs stop`. Requires --confirm"
+  ).argument("<clientId>", "workspace client id (wcid)").option("--confirm", "required \u2014 acknowledge that every live run of this customer ends").action(async (clientId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, `stop every workflow run of client ${clientId}`);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.stopClientAutomationRuns(clientId);
+    emit(flags, result, () => printStoppedRuns(result));
+  });
+}
 
 // src/commands/clients/emails.ts
 import { readFileSync as readFileSync6 } from "fs";
@@ -14591,6 +15520,42 @@ function registerClientEmailsCommands(clients2) {
       });
     }
   );
+  emails.command("delete-drafts").description(
+    "Delete DRAFTS (and failed hand-offs) across customers: the listed ids, every draft with one subject, or all. Sent e-mails are never touched. --preview only counts; a delete needs --confirm and never removes more than it counted"
+  ).option("--ids <a,b,...>", "draft ids (from `clients emails inbox`)", parseCommaList("--ids")).option("--subject <subject>", "every draft whose subject is exactly this").option("--all", "every draft of the workspace").option("--preview", "count the matching drafts, delete nothing").option("--confirm", "required to delete \u2014 acknowledge the drafts are deleted for good").action(
+    async (options, command) => {
+      const flags = getGlobalFlags(command);
+      const scope = draftsScope(options);
+      if (!options.preview) requireConfirm(options.confirm, "delete client e-mail drafts");
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const counted = await client.deleteClientEmailDrafts({ ...scope, preview: true });
+      if (options.preview || counted.matchedCount === 0) {
+        emit(flags, counted, () => printDraftsCount(counted, "match"));
+        return;
+      }
+      const result = await client.deleteClientEmailDrafts({
+        ...scope,
+        maxCount: counted.matchedCount
+      });
+      emit(flags, result, () => printDraftsCount(result, "deleted"));
+    }
+  );
+}
+function draftsScope(options) {
+  const chosen = [options.ids !== void 0, options.subject !== void 0, options.all === true];
+  if (chosen.filter(Boolean).length !== 1) {
+    throw new Error("Pass exactly one of --ids, --subject or --all.");
+  }
+  if (options.ids !== void 0) return { scope: "ids", emailIds: options.ids };
+  if (options.subject !== void 0) return { scope: "subject", subject: options.subject };
+  return { scope: "all" };
+}
+function printDraftsCount(result, verb) {
+  const count2 = verb === "deleted" ? result.deletedCount : result.matchedCount;
+  process.stdout.write(
+    `${count2} draft(s) ${verb === "deleted" ? "deleted" : "match (nothing deleted)"}${result.sampleSubjects.length > 0 ? `, e.g. "${result.sampleSubjects.join('", "')}"` : ""}.
+`
+  );
 }
 
 // src/commands/clients/subscription.ts
@@ -15079,59 +16044,70 @@ function readImportCsv(csvFile) {
   }
   return contacts;
 }
-function printMergePreview(preview) {
+function printMergePreview(preview2) {
   process.stdout.write("Merge preview (dry run \u2014 nothing was written)\n");
-  process.stdout.write(`  Survivor: ${preview.survivorWcid} (${preview.survivorEmail})
-`);
-  process.stdout.write(`  Duplicate (tombstoned): ${preview.loserWcid} (${preview.loserEmail})
+  process.stdout.write(`  Survivor: ${preview2.survivorWcid} (${preview2.survivorEmail})
 `);
-  if (preview.blocked !== null) {
-    process.stdout.write(`  \u26A0\uFE0F BLOCKED \u2014 live subscription(s); the merge will be refused (409):
+  process.stdout.write(`  Duplicate (tombstoned): ${preview2.loserWcid} (${preview2.loserEmail})
 `);
-    for (const sub of preview.blocked.subscriptions) {
+  if (preview2.blocked !== null) {
+    process.stdout.write(
+      preview2.blocked.reason === "subscription-vs-lifetime" ? `  \u26A0\uFE0F BLOCKED \u2014 one client has a subscription, the other lifetime access to the same product; the merge will be refused (409). End the subscription first, or contact Zanfia:
+` : `  \u26A0\uFE0F BLOCKED \u2014 live subscription(s); the merge will be refused (409):
+`
+    );
+    for (const sub of preview2.blocked.subscriptions) {
       process.stdout.write(
         `    - ${sub.side}: subscription ${sub.subscriptionId} on product ${sub.productId}
 `
       );
     }
+    if (preview2.blocked.reason === "subscription-vs-lifetime") {
+      for (const grant of preview2.blocked.lifetimeGrants) {
+        process.stdout.write(
+          `    - ${grant.side}: lifetime access to product ${grant.productId}
+`
+        );
+      }
+    }
   }
   process.stdout.write(
-    `  Money: ${preview.money.survivorTotalSpentMinor} + ${preview.money.loserTotalSpentMinor} = ${preview.money.sumMinor} (minor units); ${preview.money.ordersMovingCount} order${preview.money.ordersMovingCount === 1 ? "" : "s"} moving
+    `  Money: ${preview2.money.survivorTotalSpentMinor} + ${preview2.money.loserTotalSpentMinor} = ${preview2.money.sumMinor} (minor units); ${preview2.money.ordersMovingCount} order${preview2.money.ordersMovingCount === 1 ? "" : "s"} moving
 `
   );
-  if (preview.grants.length > 0) {
-    process.stdout.write(`  Product access grants (${preview.grants.length}):
+  if (preview2.grants.length > 0) {
+    process.stdout.write(`  Product access grants (${preview2.grants.length}):
 `);
-    for (const grant of preview.grants) {
+    for (const grant of preview2.grants) {
       process.stdout.write(
         `    - ${grant.productName} (${grant.productId}): ${grant.action} \u2014 ${grant.reason}
 `
       );
     }
   }
-  if (preview.profileOverwrites.length > 0) {
+  if (preview2.profileOverwrites.length > 0) {
     process.stdout.write("  Profile fields where the duplicate's value is DISCARDED:\n");
-    for (const overwrite of preview.profileOverwrites) {
+    for (const overwrite of preview2.profileOverwrites) {
       process.stdout.write(
         `    - ${overwrite.field}: keeping "${overwrite.survivorValueKept ?? ""}", discarding "${overwrite.loserValueDiscarded ?? ""}"${overwrite.downstreamUnlink ? " (downstream unlink)" : ""}
 `
       );
     }
   }
-  if (preview.community.communitiesTouchedCount > 0) {
+  if (preview2.community.communitiesTouchedCount > 0) {
     process.stdout.write(
-      `  Communities touched: ${preview.community.communitiesTouchedCount}; ~${preview.community.authoredRePointCount} authored posts/comments re-pointed
+      `  Communities touched: ${preview2.community.communitiesTouchedCount}; ~${preview2.community.authoredRePointCount} authored posts/comments re-pointed
 `
     );
   }
   process.stdout.write(
-    `  Resulting previous emails: ${preview.resultingPreviousEmails.join(", ") || "(none)"}
+    `  Resulting previous emails: ${preview2.resultingPreviousEmails.join(", ") || "(none)"}
 `
   );
   process.stdout.write("\n  This merge is IRREVERSIBLE once executed.\n");
-  if (preview.blocked === null) {
+  if (preview2.blocked === null) {
     process.stdout.write(
-      `  To execute: clients merge --survivor ${preview.survivorWcid} --duplicate ${preview.loserWcid} --preview-hash ${preview.previewHash}
+      `  To execute: clients merge --survivor ${preview2.survivorWcid} --duplicate ${preview2.loserWcid} --preview-hash ${preview2.previewHash}
 `
     );
   }
@@ -15598,7 +16574,7 @@ Next page: --cursor ${page.nextCursor}
     emit(flags, result, () => printMergePreview(result.preview));
   });
   clients2.command("merge").description(
-    "\u26A0\uFE0F IRREVERSIBLY merge the duplicate client into the survivor \u2014 grants move/dedupe, community content re-points, and the duplicate is TOMBSTONED (no undo). Run `clients merge-preview` first and pass its previewHash; a stale hash is refused (409). Live subscriptions on either side block the merge"
+    "\u26A0\uFE0F IRREVERSIBLY merge the duplicate client into the survivor \u2014 grants move/dedupe, community content re-points, and the duplicate is TOMBSTONED (no undo). Run `clients merge-preview` first and pass its previewHash; a stale hash is refused (409). A live subscription on both sides of one product blocks the merge, and so does a live subscription on one side against lifetime access on the other (409)"
   ).requiredOption("--survivor <clientId>", "the client that remains (wcid)").requiredOption("--duplicate <clientId>", "the client merged in and tombstoned (wcid)").requiredOption(
     "--preview-hash <hash>",
     "previewHash from a fresh `clients merge-preview` for the same pair"
@@ -15854,6 +16830,7 @@ Next page: --cursor ${page.nextCursor}
   });
   registerClientSubscriptionCommands(clients2);
   registerClientEmailsCommands(clients2);
+  registerClientAutomationRunsCommands(clients2);
 }
 
 // src/commands/communities/index.ts
@@ -15971,6 +16948,100 @@ var MODERATION_COLUMNS = [
   "createdAt",
   "status"
 ];
+function joinRequestRow(request) {
+  return {
+    id: request.id,
+    name: [request.firstName, request.lastName].filter(Boolean).join(" "),
+    email: request.email,
+    status: request.status,
+    requestedAt: request.requestedAt,
+    answers: request.answers.length,
+    aiHint: request.aiHint?.verdict ?? ""
+  };
+}
+var JOIN_REQUEST_COLUMNS = [
+  "id",
+  "name",
+  "email",
+  "status",
+  "requestedAt",
+  "answers",
+  "aiHint"
+];
+function assertIdCount(ids, max) {
+  if (ids.length > max) {
+    throw new Error(
+      `Pass at most ${max} request ids per call (got ${ids.length}); run it again for the rest.`
+    );
+  }
+}
+function printJoinDecisions(result) {
+  printTable(
+    result.results.map((r) => ({
+      requestId: r.requestId,
+      outcome: r.outcome,
+      message: r.message ?? ""
+    })),
+    ["requestId", "outcome", "message"]
+  );
+}
+var DIGEST_OUTCOME_LABELS = {
+  approved: "Approved \u2014 the digest goes out Thursday 09:00.",
+  approvedSendingNow: "Approved \u2014 the send starts now.",
+  alreadyApproved: "Already approved \u2014 nothing changed.",
+  skipped: "Skipped \u2014 no digest goes out this week.",
+  alreadySkipped: "Already skipped \u2014 nothing changed."
+};
+function digestRow(draft) {
+  return {
+    week: draft.weekKey,
+    status: draft.skipReason ? `${draft.status} (${draft.skipReason})` : draft.status,
+    sendAt: draft.sendAt,
+    sentAt: draft.sentAt ?? "",
+    recipients: draft.recipientsCount ?? ""
+  };
+}
+var DIGEST_COLUMNS = ["week", "status", "sendAt", "sentAt", "recipients"];
+function printDigestDraft(draft) {
+  process.stdout.write(
+    `Week ${draft.weekKey}: ${draft.status}${draft.skipReason ? ` (${draft.skipReason})` : ""}
+`
+  );
+  process.stdout.write(`  Send at: ${draft.sendAt} (${draft.timezone})
+`);
+  process.stdout.write(`  Approve by: ${draft.approvalDeadline}
+`);
+  const actions = [draft.canApprove ? "approve" : null, draft.canSkip ? "skip" : null].filter(
+    Boolean
+  );
+  process.stdout.write(`  Possible now: ${actions.length > 0 ? actions.join(", ") : "nothing"}
+`);
+  if (draft.sentAt) {
+    process.stdout.write(`  Sent: ${draft.sentAt} to ${draft.recipientsCount ?? 0} member(s)
+`);
+  }
+  const { preview: preview2 } = draft;
+  if (!preview2) return;
+  const { stats } = preview2;
+  process.stdout.write(
+    `  Preview (${preview2.communityName}): ${stats.postsCount} posts, ${stats.commentsCount} comments, ${stats.newMembersCount} new members
+`
+  );
+  for (const line of preview2.summaryLinesEn ?? preview2.summaryLinesPl ?? []) {
+    process.stdout.write(`    ${line.emoji} ${line.text}
+`);
+  }
+  for (const post of preview2.posts) {
+    process.stdout.write(
+      `    - ${post.title ?? post.excerpt} (${post.channelName}, ${post.authorName})
+`
+    );
+  }
+  for (const event of preview2.events) {
+    process.stdout.write(`    event: ${event.title} \u2014 ${event.dateFormatted}
+`);
+  }
+}
 function authorLabel(author) {
   const name = [author.firstName, author.lastName].filter(Boolean).join(" ");
   return author.nickname || name || author.id;
@@ -17026,6 +18097,98 @@ Not going (${result.notGoingCount}):
       }
     });
   });
+  const joinRequests = communities2.command("join-requests").description(
+    "People waiting to join a community that approves members by hand: list, approve, decline (workspace staff with member management; member keys get 403)"
+  );
+  joinRequests.command("list").description("Pending requests first (with their answers and the AI hint), then declined ones").argument("<communityId>", "community id").action(async (communityId, _, command) => {
+    const flags = getGlobalFlags(command);
+    const result = await clientFor(flags).listCommunityJoinRequests(communityId);
+    emit(flags, result, () => {
+      process.stdout.write(`Pending: ${result.pendingCount}
+`);
+      printTable(result.requests.map(joinRequestRow), JOIN_REQUEST_COLUMNS);
+      for (const request of result.requests) {
+        if (request.status !== "pending" || request.answers.length === 0) {
+          continue;
+        }
+        process.stdout.write(`
+Answers of ${request.id}:
+`);
+        for (const answer of request.answers) {
+          process.stdout.write(`  ${answer.question}
+    ${answer.answer}
+`);
+        }
+      }
+    });
+  });
+  joinRequests.command("approve").description(
+    `Approve requests \u2014 runs the normal join (welcome e-mail with the login link, welcome DM, notifications). 1-${COMMUNITY_JOIN_APPROVE_MAX_IDS} ids per call; repeats change nothing. Requires --confirm`
+  ).argument("<communityId>", "community id").argument("<requestIds...>", "request ids (from `communities join-requests list`)").option("--confirm", "required \u2014 acknowledge that the people join and get the welcome e-mail").action(
+    async (communityId, requestIds, options, command) => {
+      const flags = getGlobalFlags(command);
+      assertIdCount(requestIds, COMMUNITY_JOIN_APPROVE_MAX_IDS);
+      requireConfirm5(
+        options.confirm,
+        `approve ${requestIds.length} join request(s) (they join and get the welcome e-mail)`
+      );
+      const result = await clientFor(flags).approveCommunityJoinRequests(communityId, requestIds);
+      emit(flags, result, () => printJoinDecisions(result));
+    }
+  );
+  joinRequests.command("decline").description(
+    `Decline requests quietly (a neutral e-mail, no reason given). 1-${COMMUNITY_JOIN_DECLINE_MAX_IDS} ids per call; repeats change nothing. Requires --confirm`
+  ).argument("<communityId>", "community id").argument("<requestIds...>", "request ids (from `communities join-requests list`)").option("--confirm", "required \u2014 acknowledge that the people are declined and e-mailed").action(
+    async (communityId, requestIds, options, command) => {
+      const flags = getGlobalFlags(command);
+      assertIdCount(requestIds, COMMUNITY_JOIN_DECLINE_MAX_IDS);
+      requireConfirm5(options.confirm, `decline ${requestIds.length} join request(s)`);
+      const result = await clientFor(flags).declineCommunityJoinRequests(communityId, requestIds);
+      emit(flags, result, () => printJoinDecisions(result));
+    }
+  );
+  const digest = communities2.command("digest").description(
+    "The weekly digest e-mail to members: nothing goes out until the owner or an admin approves the week (Thursday 09:00 send, closes at the end of Thursday)"
+  );
+  digest.command("list").description("This week's draft with the preview of what members get, then the earlier weeks").argument("<communityId>", "community id").action(async (communityId, _, command) => {
+    const flags = getGlobalFlags(command);
+    const result = await clientFor(flags).listCommunityDigestDrafts(communityId);
+    emit(flags, result, () => {
+      if (!result.digestEnabled) {
+        process.stdout.write(
+          "The weekly digest is OFF for this community \u2014 no drafts are built. Turn it on in the community settings.\n"
+        );
+      }
+      if (result.current) {
+        printDigestDraft(result.current);
+      } else {
+        process.stdout.write("No draft this week.\n");
+      }
+      if (result.history.length > 0) {
+        process.stdout.write("\nEarlier weeks:\n");
+        printTable(result.history.map(digestRow), DIGEST_COLUMNS);
+      }
+    });
+  });
+  const decideDigest = (decision, what) => async (communityId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm5(options.confirm, `${what} of community ${communityId}`);
+    const result = await clientFor(flags).decideCommunityDigestDraft(communityId, {
+      decision,
+      ...options.week !== void 0 ? { weekKey: options.week } : {}
+    });
+    emit(flags, result, () => {
+      process.stdout.write(`${DIGEST_OUTCOME_LABELS[result.outcome]}
+`);
+      printDigestDraft(result.draft);
+    });
+  };
+  digest.command("approve").description(
+    "Approve the week \u2014 the digest goes out Thursday 09:00 (at once when approved later that Thursday) to every member who gets it. Owner / admin only; repeats never send twice. Requires --confirm"
+  ).argument("<communityId>", "community id").option("--week <weekKey>", "the week (from `communities digest list`); default this week").option("--confirm", "required \u2014 acknowledge that the digest is e-mailed to the members").action(decideDigest("approve", "approve the weekly digest (members are e-mailed)"));
+  digest.command("skip").description(
+    "Skip the week \u2014 no digest goes out (refused once the send has started). Owner / admin only. Requires --confirm"
+  ).argument("<communityId>", "community id").option("--week <weekKey>", "the week (from `communities digest list`); default this week").option("--confirm", "required \u2014 acknowledge that no digest goes out that week").action(decideDigest("skip", "skip the weekly digest"));
   const moderation = communities2.command("moderation").description("Reported posts and comments \u2014 review the queue and resolve reports (staff)");
   moderation.command("queue").description("Show pending reports plus the most recently resolved ones").argument("<communityId>", "community id").action(async (communityId, _, command) => {
     const flags = getGlobalFlags(command);
@@ -17081,10 +18244,16 @@ var SETTINGS_PATCH_KEYS = [
   "eventsEnabled",
   "eventAnnouncements",
   "directMessagesEnabled",
+  "membersCanCreateGroups",
+  "channelTypeIcons",
+  "channelGroupsCollapsed",
   "gamification",
   "moderation",
   "assistant",
-  "digest"
+  "digest",
+  "welcomeMessage",
+  "joinQuestions",
+  "joinApproval"
 ];
 function parseSettingsPatch(value) {
   const parsed = parseJsonObject(value, "--patch");
@@ -17110,7 +18279,100 @@ function parseJsonObject(value, flag) {
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(`${flag} must be a JSON object.`);
   }
-  return parsed;
+  return parsed;
+}
+
+// src/commands/consultations/index.ts
+function assertBookingStatus(value) {
+  const match = CONSULTATION_BOOKING_STATUSES.find((status) => status === value);
+  if (match === void 0) {
+    throw new Error(
+      `Invalid --status: ${value}. Use one of: ${CONSULTATION_BOOKING_STATUSES.join(", ")}`
+    );
+  }
+  return match;
+}
+function assertDate(value, flag) {
+  if (Number.isNaN(Date.parse(value))) {
+    throw new Error(`Invalid ${flag}: ${value} (expected an ISO date, e.g. 2026-11-01)`);
+  }
+  return value;
+}
+function printNextPage(nextCursor) {
+  if (nextCursor) process.stdout.write(`
+Next page: --cursor ${nextCursor}
+`);
+}
+function registerConsultationsCommands(program2) {
+  const consultations = program2.command("consultations").description(
+    "Consultations booked in the Zanfia calendar: booked sessions and buyers who never booked"
+  );
+  consultations.command("bookings").description(
+    "Booked sessions of every consultation (or --product) starting in a date range, earliest first, with the client name and e-mail"
+  ).option("--product <productId>", "only this consultation product").option("--from <date>", "range start (ISO or YYYY-MM-DD; default today 00:00 UTC)").option("--to <date>", "range end, exclusive (default from + 30 days; at most 366 days)").option("--status <status>", CONSULTATION_BOOKING_STATUSES.join("|")).option(
+    "--limit <n>",
+    "page size (default 50, max 100)",
+    parseNumberOption("--limit", NumberFormat.Integer)
+  ).option("--cursor <cursor>", "cursor from a previous page").action(
+    async (options, command) => {
+      const flags = getGlobalFlags(command);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const page = await client.listConsultationBookings({
+        productId: options.product,
+        from: options.from !== void 0 ? assertDate(options.from, "--from") : void 0,
+        to: options.to !== void 0 ? assertDate(options.to, "--to") : void 0,
+        status: options.status !== void 0 ? assertBookingStatus(options.status) : void 0,
+        limit: options.limit,
+        cursor: options.cursor
+      });
+      emit(flags, page, () => {
+        process.stdout.write(`Sessions starting ${page.from} .. ${page.to}
+`);
+        printTable(
+          page.items.map((b) => ({
+            bookingId: b.bookingId,
+            product: b.productName ?? b.productId,
+            start: b.startAt,
+            minutes: b.durationMinutes,
+            client: b.clientName ? `${b.clientName} <${b.clientEmail}>` : b.clientEmail,
+            status: b.status,
+            location: b.location
+          })),
+          ["bookingId", "product", "start", "minutes", "client", "status", "location"]
+        );
+        printNextPage(page.nextCursor);
+      });
+    }
+  );
+  consultations.command("without-booking").description(
+    "Buyers with active access to a consultation (every one, or --product) who never booked a session (a cancelled booking does not count). External-link consultations are skipped"
+  ).option("--product <productId>", "only this consultation product").option(
+    "--limit <n>",
+    "page size (default 50, max 100)",
+    parseNumberOption("--limit", NumberFormat.Integer)
+  ).option("--cursor <cursor>", "cursor from a previous page").action(
+    async (options, command) => {
+      const flags = getGlobalFlags(command);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const page = await client.listConsultationClientsWithoutBooking({
+        productId: options.product,
+        limit: options.limit,
+        cursor: options.cursor
+      });
+      emit(flags, page, () => {
+        printTable(
+          page.items.map((c) => ({
+            clientId: c.clientId,
+            client: c.clientName ? `${c.clientName} <${c.clientEmail}>` : c.clientEmail,
+            product: c.productName,
+            accessSince: c.accessGrantedAt ?? ""
+          })),
+          ["clientId", "client", "product", "accessSince"]
+        );
+        printNextPage(page.nextCursor);
+      });
+    }
+  );
 }
 
 // src/commands/conversations/index.ts
@@ -17516,6 +18778,18 @@ function assertStatus(status) {
     throw new Error(`Invalid status "${status}". Use one of: ${LESSON_STATUSES.join(", ")}`);
   }
 }
+function assertOneOf2(value, allowed, flag) {
+  const match = allowed.find((candidate) => candidate === value);
+  if (match === void 0) {
+    throw new Error(`Invalid ${flag}: ${value}. Use one of: ${allowed.join(", ")}`);
+  }
+  return match;
+}
+var QUESTION_EXCERPT_LENGTH = 60;
+function excerpt(content) {
+  const line = content.replace(/\s+/g, " ").trim();
+  return line.length > QUESTION_EXCERPT_LENGTH ? `${line.slice(0, QUESTION_EXCERPT_LENGTH - 1)}\u2026` : line;
+}
 function collectRepeatable3(value, previous) {
   return [...previous, value];
 }
@@ -18301,6 +19575,110 @@ ${NOT_SAVED_NOTE} --moments=${options.out ?? "<file>"} --confirm\`.
       });
     }
   );
+  const questions = courses.command("questions").description("Learners' questions under the lessons: read, reply as the team, hide, accept");
+  questions.command("list").description("Questions of a course, newest first, each with its replies (private ones too)").argument("<productId>", "course product id").option("--filter <filter>", LESSON_QA_INBOX_FILTERS.join("|") + " (default all)").option("--lesson <lessonId>", "only the questions under this lesson").option("--cursor <cursor>", "cursor from a previous page").action(
+    async (productId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const filter = options.filter !== void 0 ? assertOneOf2(options.filter, LESSON_QA_INBOX_FILTERS, "--filter") : void 0;
+      const result = await clientFor2(flags).listCourseQuestions(productId, {
+        filter,
+        lessonId: options.lesson,
+        cursor: options.cursor
+      });
+      emit(flags, result, () => {
+        printTable(
+          result.questions.map((q) => ({
+            id: q.id,
+            lesson: q.lessonId,
+            by: q.author.displayName,
+            visibility: q.visibility,
+            status: q.status,
+            replies: q.repliesCount,
+            answered: q.staffReplied ? "yes" : "no",
+            accepted: q.acceptedReplyId ?? "",
+            question: excerpt(q.content)
+          })),
+          [
+            "id",
+            "lesson",
+            "by",
+            "visibility",
+            "status",
+            "replies",
+            "answered",
+            "accepted",
+            "question"
+          ]
+        );
+        if (result.nextCursor) {
+          process.stdout.write(`
+Next page: --cursor ${result.nextCursor}
+`);
+        }
+      });
+    }
+  );
+  questions.command("reply").description(
+    "Reply to a question as the course team \u2014 the learner sees it under the lesson and is notified. Requires --confirm"
+  ).argument("<productId>", "course product id").argument("<questionId>", "question id (from `courses questions list`)").option("--content <text>", "the reply text").option("--content-file <path>", "read the reply text from a file").option("--confirm", "required \u2014 acknowledge that the learner sees the reply").action(
+    async (productId, questionId, options, command) => {
+      const flags = getGlobalFlags(command);
+      if (options.content !== void 0 && options.contentFile !== void 0) {
+        throw new Error("Use either --content or --content-file, not both.");
+      }
+      const content = options.contentFile !== void 0 ? readFileSync10(options.contentFile, "utf8") : options.content;
+      if (content === void 0 || !content.trim()) {
+        throw new Error("Pass the reply with --content or --content-file.");
+      }
+      requireConfirm(options.confirm, `reply to question ${questionId} (the learner sees it)`);
+      const result = await clientFor2(flags).replyToCourseQuestion(productId, questionId, content);
+      emit(flags, result, () => {
+        process.stdout.write(`Replied to question ${questionId} (reply ${result.reply.id}).
+`);
+      });
+    }
+  );
+  questions.command("status").description(
+    "Hide a question or a reply from learners (the team still sees it), or publish it again. Requires --confirm"
+  ).argument("<productId>", "course product id").argument("<entryId>", "question or reply id").requiredOption("--status <status>", SETTABLE_LESSON_QA_ENTRY_STATUSES.join("|")).option("--confirm", "required \u2014 acknowledge the change learners see").action(
+    async (productId, entryId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const status = assertOneOf2(
+        options.status,
+        SETTABLE_LESSON_QA_ENTRY_STATUSES,
+        "--status"
+      );
+      requireConfirm(options.confirm, `set ${entryId} to ${status}`);
+      const result = await clientFor2(flags).setCourseQuestionStatus(productId, entryId, status);
+      emit(flags, result, () => {
+        process.stdout.write(`${result.entry.id} is now ${result.entry.status}.
+`);
+      });
+    }
+  );
+  questions.command("accept").description(
+    "Mark a reply as the answer to its question (--clear removes the mark). Requires --confirm"
+  ).argument("<productId>", "course product id").argument("<questionId>", "question id").option("--reply <replyId>", "the reply to mark as the answer").option("--clear", "remove the answer mark").option("--confirm", "required \u2014 acknowledge the change learners see").action(
+    async (productId, questionId, options, command) => {
+      const flags = getGlobalFlags(command);
+      if (options.reply === void 0 === (options.clear !== true)) {
+        throw new Error("Pass exactly one of --reply <replyId> or --clear.");
+      }
+      const replyId = options.reply ?? null;
+      requireConfirm(
+        options.confirm,
+        replyId ? `mark reply ${replyId} as the answer` : `clear the answer of question ${questionId}`
+      );
+      const result = await clientFor2(flags).acceptCourseAnswer(productId, questionId, replyId);
+      emit(flags, result, () => {
+        process.stdout.write(
+          result.acceptedReplyId ? `Reply ${result.acceptedReplyId} is the answer to question ${result.questionId}.
+` : `Question ${result.questionId} has no accepted answer now.
+`
+        );
+      });
+    }
+  );
 }
 
 // src/commands/discounts/index.ts
@@ -18728,6 +20106,40 @@ function registerEmailSenderCommands(emails) {
       );
     });
   });
+  sender.command("warmups").description(
+    "Each sending domain's warm-up (KI#1651): new domains send campaigns in hourly batches for a few days; shows the state, why a domain counts as warmed and the cap per hour"
+  ).action(async (_, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.getSenderDomainWarmups();
+    emit(flags, result, () => printWarmups(result.warmups));
+  });
+  sender.command("declare-warmed").description(
+    "\u201EWysy\u0142am z tej domeny w innym narz\u0119dziu\u201D: switch the warm-up of a verified domain off at once, recorded under your name. Requires --confirm and the campaigns.manage permission"
+  ).argument("<domain>", "the sending domain (from `emails sender warmups`)").option("--confirm", "required \u2014 acknowledge campaigns go out from it without batches").action(async (domain, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, `switch off the warm-up of ${domain}`);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.declareSenderDomainWarmed(domain);
+    emit(flags, result, () => {
+      process.stdout.write(`Warm-up of ${result.warmup.domain} is off.
+`);
+      printWarmups([result.warmup]);
+    });
+  });
+}
+function printWarmups(warmups) {
+  printTable(
+    warmups.map((warmup) => ({
+      domain: warmup.domain,
+      state: warmup.state,
+      reason: warmup.warmedReason ?? "",
+      day: warmup.warmupDay ?? "",
+      capPerHour: warmup.hourlyCap ?? "",
+      canDeclare: warmup.canDeclare ? "yes" : ""
+    })),
+    ["domain", "state", "reason", "day", "capPerHour", "canDeclare"]
+  );
 }
 
 // src/commands/emails/index.ts
@@ -19669,16 +21081,33 @@ function registerFormsCommands(program2) {
     emit(flags, result, () => {
       printTable(
         result.submissions.map((s) => ({
+          id: s.id,
           email: s.email,
           firstName: s.firstName ?? "",
           clientId: s.clientId ?? "",
           language: s.language ?? "",
           createdAt: s.createdAt
         })),
-        ["email", "firstName", "clientId", "language", "createdAt"]
+        ["id", "email", "firstName", "clientId", "language", "createdAt"]
       );
     });
   });
+  forms.command("room-link").description(
+    "E-mail a webinar registrant their personal room link again (to THEIR address; one per sign-up per 10 minutes). Requires --confirm"
+  ).argument("<formId>", "the webinar sign-up form id").argument("<submissionId>", "the submission id (from `forms submissions`)").option("--confirm", "required \u2014 acknowledge the registrant is e-mailed").action(
+    async (formId, submissionId, options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm(options.confirm, `e-mail the room link of submission ${submissionId}`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.resendFormSubmissionRoomLink(formId, submissionId);
+      emit(
+        flags,
+        result,
+        () => process.stdout.write(`Room link e-mailed again for submission ${submissionId}.
+`)
+      );
+    }
+  );
 }
 
 // src/commands/funnels/index.ts
@@ -19701,6 +21130,7 @@ var FUNNEL_TEMPLATE_IDS = [
   "challenge"
 ];
 var EVENT_MODES = ["live", "on_demand"];
+var OFFER_PAGE_LAYOUTS = ["digital", "physical"];
 var SCHEDULER_UNAVAILABLE_STATUS2 = 503;
 var FUNNEL_NOT_READY_STATUS = 409;
 function requireConfirm6(confirm, what) {
@@ -20020,6 +21450,37 @@ function registerFunnelsCommands(program2) {
       emit(flags, result, () => {
         process.stdout.write(
           `Generation queued for step ${stepId} (run ${result.runId}). It takes 1-5 minutes; run "funnels get ${id}" to see the page once it lands.
+`
+        );
+      });
+    }
+  );
+  funnels.command("add-offer-page").description(
+    'Add a designed one-time-offer page right AFTER a signup page step (the dashboard canvas "Add step > Offer"): a template in the signup page colors with a 30-minute timer, "yes" pays for --checkout on the page, "no thanks" goes to the step that followed the signup. The signup redirects to it and the funnel gets the step (in place of the free checkout\'s empty OTO step right after the signup, when there is one). Created as a DRAFT page (edit it, then `pages publish`); template copy, no AI credits. A live funnel is refused: switch it to draft first.'
+  ).argument("<id>", "funnel id").requiredOption(
+    "--checkout <checkoutId>",
+    "the PAID checkout the offer sells, with a slug (active or inactive; never a free one)"
+  ).requiredOption(
+    "--layout <layout>",
+    `${OFFER_PAGE_LAYOUTS.join(" | ")} (digital = ebook / mini course, physical = free + shipping)`
+  ).option(
+    "--after <n|id>",
+    "the signup step to follow: its 1-based position (`funnels get`) or stepId; default the first"
+  ).option("--lang <en|pl>", "language of the template copy (default en)").action(
+    async (id, options, command) => {
+      const flags = getGlobalFlags(command);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const afterStepId = options.after !== void 0 ? await resolveStepId(client, id, options.after) : void 0;
+      const input = {
+        checkoutId: options.checkout,
+        layout: parseChoice3(options.layout, OFFER_PAGE_LAYOUTS, "--layout"),
+        ...afterStepId ? { afterStepId } : {},
+        ...options.lang !== void 0 ? { lang: parseChoice3(options.lang, FUNNEL_LANGS, "--lang") } : {}
+      };
+      const result = await client.addFunnelOfferPage(id, input);
+      emit(flags, result, () => {
+        process.stdout.write(
+          `Added the DRAFT offer page /${result.slug} (page ${result.pageId}, step ${result.stepId}) after step ${result.afterStepId}. The body copy and the crossed-out price are template samples (the button and price spans show the checkout's real price): edit the copy, then publish it.
 `
         );
       });
@@ -20046,7 +21507,7 @@ function registerFunnelsCommands(program2) {
     });
   });
   funnels.command("from-template").description(
-    "Create a funnel from a catalog template (`funnels templates`) AND AI-generate its page steps in one go \u2014 opt-in / sales / thank-you pages are queued as background generations (202; consumes AI credits, 1-5 minutes each). The template\u2019s product requirement must be met (free or paid checkout on the product), else 409. Webinar template: pass the event fields (live; --join-url for a ClickMeeting / Zoom link) or --event-mode on_demand, or --live-room <roomId> to run it on a webinar that plays a recording (then --product is optional; needs the live_rooms plan feature). Requires --confirm."
+    "Create a funnel from a catalog template (`funnels templates`) AND AI-generate its page steps in one go \u2014 opt-in / sales / thank-you pages are queued as background generations (202; consumes AI credits, 1-5 minutes each). The template\u2019s product requirement must be met (free or paid checkout on the product), else 409. Webinar template: pass the event fields (live; --join-url for a ClickMeeting / Zoom link) or --event-mode on_demand, or --live-room <roomId> to run it on a webinar that plays a recording or an external one (`live-rooms create`; then --product is optional; needs the live_rooms plan feature). Requires --confirm."
   ).argument("<templateId>", `template id (${FUNNEL_TEMPLATE_IDS.join(" | ")})`).option(
     "--product <productId>",
     "the product the funnel sells or delivers (required, except with --live-room)"
@@ -20058,7 +21519,7 @@ function registerFunnelsCommands(program2) {
     "webinar (live): the meeting link (ClickMeeting, Zoom, Teams, Meet) the pages and reminders carry"
   ).option(
     "--live-room <roomId>",
-    "webinar: a webinar (`live-rooms list`) that plays a recording; its sessions are the event"
+    "webinar: a webinar (`live-rooms list`) that plays a recording, or an external one (`live-rooms create`); its sessions are the event"
   ).option(
     "--page-template <id>",
     "design template for every generated page (a page-template id, e.g. course-fresh); thank-you steps take the companion"
@@ -21294,6 +22755,17 @@ to refresh it.
 }
 
 // src/commands/liveRooms/index.ts
+var STUDIO_SCENE_LAYOUTS = ["solo", "presentation", "grid"];
+function parseSceneLayout(value) {
+  const layout = STUDIO_SCENE_LAYOUTS.find((candidate) => candidate === value);
+  if (!layout) throw new Error(`--layout must be one of ${STUDIO_SCENE_LAYOUTS.join(", ")}`);
+  return layout;
+}
+function parseOnOff4(value) {
+  if (value === "on") return true;
+  if (value === "off") return false;
+  throw new Error(`expected on or off, got "${value}"`);
+}
 var minutes = (seconds) => `${Math.round(seconds / 60)} min`;
 var percent = (part, whole) => whole > 0 ? `${Math.round(part / whole * 100)}%` : "-";
 var countOrDash = (value) => value === null || value === void 0 ? "-" : String(value);
@@ -21319,9 +22791,33 @@ function describeSchedule(room) {
   }
   return `every ${room.schedule.everyMinutes} min${until}${exclusions}`;
 }
+function isMeetingLink(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname !== "";
+  } catch {
+    return false;
+  }
+}
+function printRoom(result) {
+  const { room } = result;
+  printTable(
+    [
+      {
+        id: room.id,
+        title: room.title,
+        startAt: room.startAt,
+        endAt: room.endAt,
+        link: room.externalUrl ?? "",
+        replay: room.replay ? room.replay.name ?? room.replay.mediaId : ""
+      }
+    ],
+    ["id", "title", "startAt", "endAt", "link", "replay"]
+  );
+}
 function registerLiveRoomsCommands(program2) {
   const liveRooms = program2.command("live-rooms").description(
-    "Webinars (incl. rolling autowebinar sessions) \u2014 list and attendance; webinars are managed in the dashboard"
+    "Webinars (incl. rolling autowebinar sessions) \u2014 list, attendance, and an external webinar (ClickMeeting, Zoom, Teams, Meet) with its recording; the rest in the dashboard"
   );
   liveRooms.command("list").description("List webinars (latest start first)").action(async (_, command) => {
     const flags = getGlobalFlags(command);
@@ -21342,6 +22838,131 @@ function registerLiveRoomsCommands(program2) {
       );
     });
   });
+  liveRooms.command("create").description(
+    "An external webinar (ClickMeeting, Zoom, Teams, Meet): the webinar page counts down, from 15 min before the start \u201EWejd\u017A na webinar\u201D opens the link and counts the person as present. Then: funnels from-template webinar --live-room <id>"
+  ).requiredOption("--title <title>", "webinar title").requiredOption("--start <iso>", "start, ISO 8601 (e.g. 2026-11-27T19:00:00+01:00)").requiredOption("--join-url <url>", "the meeting link (https)").option("--duration <minutes>", "length in minutes (5-720)", "90").option("--timezone <zone>", "IANA zone the webinar is shown in", "Europe/Warsaw").option("--description <text>", "one or two sentences about it").action(
+    async (options, command) => {
+      const flags = getGlobalFlags(command);
+      const durationMinutes = Number(options.duration);
+      if (!Number.isInteger(durationMinutes) || durationMinutes < 5 || durationMinutes > 720) {
+        throw new Error("--duration must be a whole number of minutes from 5 to 720");
+      }
+      if (Number.isNaN(Date.parse(options.start))) {
+        throw new Error("--start must be an ISO 8601 date-time");
+      }
+      if (!isMeetingLink(options.joinUrl)) {
+        throw new Error("--join-url must be an https link");
+      }
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.createExternalWebinar({
+        title: options.title,
+        ...options.description !== void 0 ? { description: options.description } : {},
+        startAt: options.start,
+        durationMinutes,
+        timezone: options.timezone,
+        url: options.joinUrl
+      });
+      emit(flags, result, () => {
+        printRoom(result);
+        process.stdout.write(
+          `
+Next: zanfia funnels from-template webinar --live-room ${result.room.id} --lang pl --confirm (the sign-up page, thank-you page and reminders on it).
+`
+        );
+      });
+    }
+  );
+  liveRooms.command("replay").description(
+    "An external webinar's recording, attached after it ran (a ready Media Library video, e.g. from media upload): the webinar page plays it as the replay"
+  ).argument("<roomId>", "webinar id (from live-rooms list)").option("--media <mediaId>", "the recording (Media Library video id)").option("--remove", "take the recording off").action(
+    async (roomId, options, command) => {
+      const flags = getGlobalFlags(command);
+      if (Boolean(options.media) === Boolean(options.remove)) {
+        throw new Error("pass exactly one of --media <mediaId> or --remove");
+      }
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.setLiveRoomReplay(roomId, options.media ?? null);
+      emit(flags, result, () => printRoom(result));
+    }
+  );
+  liveRooms.command("scene").description(
+    "A studio webinar's broadcast picture (studio scenes, early access): layout, banner, the name under the camera, the offer and the featured chat question on screen. Only the options you pass change"
+  ).argument("<roomId>", "studio webinar id (from live-rooms list)").option("--layout <layout>", "solo | presentation | grid").option("--banner <text>", "the banner along the top").option("--no-banner", "remove the banner").option("--name <name>", "the name under the camera (lower third)").option("--title <title>", "the line under the name").option("--no-lower-third", "remove the name under the camera").option("--offer <on|off>", "the webinar's offer as a card in the picture").option("--comment <on|off>", "the featured chat question in the picture").option("--logo <on|off>", "the logo in the corner").action(
+    async (roomId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const input = {
+        ...options.layout !== void 0 ? { layout: parseSceneLayout(options.layout) } : {},
+        ...options.banner === false ? { banner: null } : options.banner !== void 0 ? { banner: options.banner } : {},
+        ...options.lowerThird === false ? { lowerThird: null } : options.name !== void 0 ? { lowerThird: { name: options.name, title: options.title ?? null } } : {},
+        ...options.offer !== void 0 ? { offerOnScreen: parseOnOff4(options.offer) } : {},
+        ...options.comment !== void 0 ? { commentOnScreen: parseOnOff4(options.comment) } : {},
+        ...options.logo !== void 0 ? { showLogo: parseOnOff4(options.logo) } : {}
+      };
+      if (Object.keys(input).length === 0) {
+        throw new Error("pass at least one option (e.g. --layout presentation)");
+      }
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.setLiveRoomStudioScene(roomId, input);
+      emit(flags, result, () => {
+        printTable(
+          [
+            {
+              layout: result.scene.layout,
+              banner: result.scene.banner ?? "",
+              lowerThird: result.scene.lowerThird?.name ?? "",
+              offer: result.scene.offerOnScreen ? "on" : "off",
+              comment: result.scene.commentOnScreen ? "on" : "off",
+              onAir: result.appliedToRoom ? "yes" : "next go-live"
+            }
+          ],
+          ["layout", "banner", "lowerThird", "offer", "comment", "onAir"]
+        );
+      });
+    }
+  );
+  const guestRow = (guest) => ({
+    id: guest.id,
+    name: guest.name,
+    state: guest.state,
+    inStudio: guest.connected ? "yes" : "no",
+    muted: guest.mutedForStream ? "yes" : "no",
+    expiresAt: guest.expiresAt
+  });
+  const GUEST_COLUMNS = ["id", "name", "state", "inStudio", "muted", "expiresAt"];
+  liveRooms.command("guest-invite").description(
+    "Invite a guest into a studio webinar's studio (early access): prints their personal link ONCE (only its hash is kept; nothing is sent). They join backstage, the host puts them on stage"
+  ).argument("<roomId>", "studio webinar id (from live-rooms list)").requiredOption("--name <name>", "the guest's name (shown under their camera)").option("--email <email>", "for your own reference; nothing is sent to it").action(async (roomId, options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.createLiveRoomStudioGuestInvite(roomId, {
+      name: options.name,
+      email: options.email ?? null
+    });
+    emit(flags, result, () => {
+      printTable(
+        [{ ...guestRow(result.guest), inviteUrl: result.inviteUrl }],
+        [...GUEST_COLUMNS, "inviteUrl"]
+      );
+    });
+  });
+  liveRooms.command("guests").description("A studio webinar's invited guests: state, in the studio now, link expiry").argument("<roomId>", "studio webinar id (from live-rooms list)").action(async (roomId, _options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.listLiveRoomStudioGuests(roomId);
+    emit(flags, result, () => {
+      printTable(result.guests.map(guestRow), GUEST_COLUMNS);
+    });
+  });
+  liveRooms.command("guest-remove").description("Remove a guest from the studio: the link stops working, they are disconnected").argument("<roomId>", "studio webinar id (from live-rooms list)").argument("<guestId>", "guest id (from live-rooms guests)").action(
+    async (roomId, guestId, _options, command) => {
+      const flags = getGlobalFlags(command);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.revokeLiveRoomStudioGuestInvite(roomId, guestId);
+      emit(flags, result, () => {
+        printTable([guestRow(result.guest)], GUEST_COLUMNS);
+      });
+    }
+  );
   liveRooms.command("attendance").description("A webinar's attendance per session; --session adds that session's viewers").argument("<roomId>", "webinar id (from live-rooms list)").option("--session <iso>", "ISO start of one session to list its attendees").action(async (roomId, options, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
@@ -25075,7 +26696,7 @@ var ACCESS_STRATEGIES = [
 ];
 var DOUBLE_OPT_INS = ["none", "external"];
 var DELIVERIES = ["zanfia", "integration"];
-function assertOneOf2(value, allowed, flag) {
+function assertOneOf3(value, allowed, flag) {
   if (!allowed.includes(value)) {
     throw new Error(`Invalid ${flag}: ${value}. Use one of: ${allowed.join(", ")}`);
   }
@@ -25171,17 +26792,17 @@ Next: \`newsletters issues draft save ${productId} ${issue.id} --content <markdo
       const flags = getGlobalFlags(command);
       const input = {};
       if (options.status !== void 0) {
-        input.status = assertOneOf2(options.status, ISSUE_STATUSES, "--status");
+        input.status = assertOneOf3(options.status, ISSUE_STATUSES, "--status");
       }
       if (options.landing !== void 0) {
-        input.landingPageVisibility = assertOneOf2(
+        input.landingPageVisibility = assertOneOf3(
           options.landing,
           ISSUE_VISIBILITIES,
           "--landing"
         );
       }
       if (options.renderMode !== void 0) {
-        input.renderMode = assertOneOf2(options.renderMode, ISSUE_RENDER_MODES, "--render-mode");
+        input.renderMode = assertOneOf3(options.renderMode, ISSUE_RENDER_MODES, "--render-mode");
       }
       if (options.thumbnail !== void 0) {
         input.thumbnailUrl = options.thumbnail === THUMBNAIL_NONE ? null : options.thumbnail;
@@ -25460,7 +27081,7 @@ Next: \`newsletters issues draft save ${productId} ${issue.id} --content <markdo
         archive.enabled = parseBool2(options.archiveEnabled, "--archive-enabled");
       }
       if (options.archiveAccess !== void 0) {
-        archive.accessStrategy = assertOneOf2(
+        archive.accessStrategy = assertOneOf3(
           options.archiveAccess,
           ACCESS_STRATEGIES,
           "--archive-access"
@@ -25470,14 +27091,14 @@ Next: \`newsletters issues draft save ${productId} ${issue.id} --content <markdo
         archive.publicationDelay = options.publicationDelay === "none" ? null : parseNonNegativeInt2(options.publicationDelay, "--publication-delay");
       }
       if (options.defaultStatus !== void 0) {
-        archive.defaultEmailStatus = assertOneOf2(
+        archive.defaultEmailStatus = assertOneOf3(
           options.defaultStatus,
           ISSUE_STATUSES,
           "--default-status"
         );
       }
       if (options.defaultVisibility !== void 0) {
-        archive.defaultEmailVisibility = assertOneOf2(
+        archive.defaultEmailVisibility = assertOneOf3(
           options.defaultVisibility,
           ISSUE_VISIBILITIES,
           "--default-visibility"
@@ -25495,11 +27116,11 @@ Next: \`newsletters issues draft save ${productId} ${issue.id} --content <markdo
         input.archiveInbox = inbox;
       }
       if (options.doubleOptIn !== void 0) {
-        input.doubleOptIn = assertOneOf2(options.doubleOptIn, DOUBLE_OPT_INS, "--double-opt-in");
+        input.doubleOptIn = assertOneOf3(options.doubleOptIn, DOUBLE_OPT_INS, "--double-opt-in");
       }
       if (options.clientTag.length > 0) input.clientTags = options.clientTag;
       if (options.delivery !== void 0) {
-        input.delivery = assertOneOf2(options.delivery, DELIVERIES, "--delivery");
+        input.delivery = assertOneOf3(options.delivery, DELIVERIES, "--delivery");
       }
       if (options.clearSender) {
         input.sender = null;
@@ -26073,7 +27694,7 @@ Media gallery (${gallery.length}):
     "suppress subscription-cancelled emails"
   ).option("--disable-end-subscription-emails <on|off>", "suppress subscription-ended emails").option(
     "--disable-access-ending-reminders <on|off>",
-    "suppress access-ending reminder emails to the client"
+    "suppress the client's access-end emails: reminders before the end and the e-mail after it (cancel-at-end offers too)"
   ).option("--facebook-pixel-id <id|none>", "legacy Facebook Pixel id (none = clear)").option("--google-analytics-id <id|none>", "legacy GA id (none = clear)").option("--gtm-id <id|none>", "legacy Google Tag Manager id (none = clear)").option("--meta-conversion-integration-id <id|none>", "legacy Meta CAPI id (none = clear)").option(
     "--tracking-integration-ids <ids|none>",
     "comma-separated workspace conversion-tracking integration ids (none = clear)"
@@ -26132,6 +27753,28 @@ Media gallery (${gallery.length}):
       });
     }
   );
+  offers.command("notify-waitlist").description(
+    "\u201EIt's back\u201D: e-mail the offer's waiting list (fr-0272), once per sign-up. Without --send it only counts; --send needs --confirm"
+  ).argument("<checkoutId>", "offer (checkout) id").option("--send", "send the e-mails (default: count only)").option("--confirm", "required with --send \u2014 acknowledge the waiting list is e-mailed").action(
+    async (checkoutId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const send = options.send === true;
+      if (send) requireConfirm(options.confirm, "e-mail this offer's waiting list");
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.notifyCheckoutWaitlist(checkoutId, !send);
+      emit(flags, result, () => {
+        process.stdout.write(
+          result.dryRun ? `${result.pendingCount} sign-up(s) of "${result.offerName}" would get the e-mail (nothing sent; add --send --confirm).
+` : `Sent to ${result.sentCount} sign-up(s) of "${result.offerName}".
+`
+        );
+        process.stdout.write(
+          `Already notified: ${result.alreadyNotifiedCount}; skipped: ${result.skippedCount} (suppressed ${result.skippedByReason.suppressed}, unsubscribed after sign-up ${result.skippedByReason.unsubscribed_after_sign_up}).
+`
+        );
+      });
+    }
+  );
   offers.command("set-default").description("Make an offer its product's default checkout").argument("<checkoutId>", "offer (checkout) id").action(async (checkoutId, _, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
@@ -26368,6 +28011,7 @@ Media gallery (${gallery.length}):
 // src/commands/orders/index.ts
 import { writeFileSync as writeFileSync5 } from "fs";
 var ORDER_STATUSES = ["paid", "pending", "refunded", "failed"];
+var REFUND_NOTE_MAX_LENGTH = 500;
 function assertOrderStatus(status) {
   if (!ORDER_STATUSES.includes(status)) {
     throw new Error(`Invalid --status: ${status}. Use one of: ${ORDER_STATUSES.join(", ")}`);
@@ -26389,8 +28033,10 @@ function requireConfirm11(confirm, what) {
     throw new Error(`Refusing to ${what} without --confirm. Re-run with --confirm to proceed.`);
   }
 }
-function registerOrdersCommands(program2) {
-  const orders2 = program2.command("orders").description("Browse orders; approve or reject manual (wire-transfer) payments");
+function registerOrdersCommands2(program2) {
+  const orders2 = program2.command("orders").description(
+    "Browse orders; approve or reject manual (wire-transfer) payments; mark test / refunded orders"
+  );
   orders2.command("list").description("List orders (newest first), with optional filters").option("--product <id>", "only orders of this product").option(
     "--status <status>",
     "filter by status (paid, pending, refunded, failed) \u2014 manual wire-transfer orders awaiting approval are `pending`"
@@ -26479,14 +28125,18 @@ Next page: --cursor ${page.nextCursor}
     });
   });
   orders2.command("approve").description(
-    "Approve a manual (wire-transfer) order \u2014 grants product access and sends the regular purchase email; --issue-invoice also issues an invoice via the connected invoicing account. 409 = the order was already decided. Requires --confirm"
-  ).argument("<orderId>", "order id (a `pending` order from `orders list --status pending`)").option("--issue-invoice", "also issue an invoice for the order (never issued without this)").option("--confirm", "required \u2014 acknowledge that access is granted and the buyer is emailed").action(
+    "Approve a manual (wire-transfer) order \u2014 grants product access and sends the regular purchase email; --issue-invoice also issues an invoice via the connected invoicing account. 409 = the order was already decided, or (stock-exhausted) an expired physical order whose stock ran out: re-run with --allow-oversell or reject it. Requires --confirm"
+  ).argument("<orderId>", "order id (a `pending` order from `orders list --status pending`)").option("--issue-invoice", "also issue an invoice for the order (never issued without this)").option(
+    "--allow-oversell",
+    "approve an expired physical order (late transfer) even though its stock ran out"
+  ).option("--confirm", "required \u2014 acknowledge that access is granted and the buyer is emailed").action(
     async (orderId, options, command) => {
       const flags = getGlobalFlags(command);
       requireConfirm11(options.confirm, `approve order ${orderId} (access + purchase email)`);
       const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
       const result = await client.approveManualOrder(orderId, {
-        issueInvoice: options.issueInvoice === true ? true : void 0
+        issueInvoice: options.issueInvoice === true ? true : void 0,
+        allowOversell: options.allowOversell === true ? true : void 0
       });
       emit(flags, result, () => {
         process.stdout.write(
@@ -26506,8 +28156,68 @@ Next page: --cursor ${page.nextCursor}
     emit(flags, result, () => {
       process.stdout.write(`Rejected order ${orderId} \u2014 cancelled and the buyer notified.
 `);
-    });
-  });
+    });
+  });
+  orders2.command("mark-test").description(
+    "Mark a real order as a test \u2014 it leaves revenue, charts and reports; the buyer keeps access. --undo puts it back. 409 = already in that state. Requires --confirm"
+  ).argument("<orderId>", "order id").option("--undo", "undo a mark made this way (the order counts again)").option("--confirm", "required \u2014 acknowledge the change to revenue and reports").action(
+    async (orderId, options, command) => {
+      const flags = getGlobalFlags(command);
+      const isTest = options.undo !== true;
+      requireConfirm11(
+        options.confirm,
+        isTest ? `mark order ${orderId} as a test` : `undo the test mark of order ${orderId}`
+      );
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.markOrderAsTest(orderId, isTest);
+      emit(flags, result, () => {
+        process.stdout.write(
+          result.isTest ? `Order ${result.orderId} is marked as a test \u2014 it no longer counts in revenue.
+` : `Order ${result.orderId} counts again in revenue and reports.
+`
+        );
+      });
+    }
+  );
+  orders2.command("mark-refunded").description(
+    "Record that you returned the money OUTSIDE Zanfia (bank transfer, cash\u2026). Nothing is charged or paid out and no correcting invoice is issued (do that in your invoicing tool); the order counts as refunded. --revoke-access also ends the buyer\u2019s access (refused while a live subscription would keep billing). Requires --confirm"
+  ).argument("<orderId>", "order id").option("--revoke-access", "also end the buyer\u2019s access to the products of this order").option(
+    "--note <text>",
+    `note on the order's audit trail (max ${REFUND_NOTE_MAX_LENGTH} chars)`
+  ).option("--confirm", "required \u2014 acknowledge that the order counts as refunded").action(
+    async (orderId, options, command) => {
+      const flags = getGlobalFlags(command);
+      if (options.note !== void 0 && options.note.length > REFUND_NOTE_MAX_LENGTH) {
+        throw new Error(`--note is too long (max ${REFUND_NOTE_MAX_LENGTH} characters).`);
+      }
+      const revokeAccess = options.revokeAccess === true;
+      requireConfirm11(
+        options.confirm,
+        `mark order ${orderId} as refunded outside Zanfia${revokeAccess ? " and end the buyer\u2019s access" : ""}`
+      );
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.markOrderRefunded(orderId, {
+        revokeAccess,
+        ...options.note !== void 0 ? { note: options.note } : {}
+      });
+      emit(flags, result, () => {
+        process.stdout.write(
+          `Order ${result.orderId} recorded as refunded outside Zanfia (${formatAmount3(result.amountMinor, result.currency)}).
+`
+        );
+        if (result.revokedProductIds.length > 0) {
+          process.stdout.write(`  Access ended: ${result.revokedProductIds.join(", ")}
+`);
+        }
+        if (result.accessRevokeFailedProductIds.length > 0) {
+          process.stdout.write(
+            `  \u26A0\uFE0F Access NOT ended for: ${result.accessRevokeFailedProductIds.join(", ")} \u2014 the refund stands; end it on the client card.
+`
+          );
+        }
+      });
+    }
+  );
   orders2.command("export").description(
     "Export orders as CSV to a file. The --from/--to window is required; same filters as `orders list`."
   ).requiredOption("--from <date>", "inclusive ISO date lower bound on createdAt (required)").requiredOption("--to <date>", "inclusive ISO date upper bound on createdAt (required)").option("--product <id>", "only orders of this product").option("--status <status>", "filter by status (paid, pending, refunded, failed)").option("--search <query>", "match client email / name").option("--include-test", "include simulated test purchases (excluded by default)").option("--max-rows <n>", "row cap (server default 10000, max 20000)").option("--out <file>", "output file path", "zanfia-orders.csv").action(
@@ -26768,6 +28478,14 @@ function buildEventInput(options) {
   };
   return Object.keys(event).length > 0 ? event : void 0;
 }
+function pointPlaceholderRefusalAtFlag(hint) {
+  return (error) => {
+    if (error instanceof ApiError && error.status === 409 && error.apiMessage.includes("allowPlaceholders")) {
+      throw new ApiError(error.status, error.apiMessage, hint);
+    }
+    throw error;
+  };
+}
 async function resolveHtml2(options) {
   if (options.file) {
     return readFile4(options.file, "utf8");
@@ -26934,7 +28652,10 @@ function registerPagesCommands(program2) {
       );
     });
   });
-  pages.command("create").description("Create a hosted page from an HTML file or inline HTML").requiredOption("--slug <slug>", "public URL slug (served at /page/<slug>)").requiredOption("--title <title>", "page title").option("--file <path>", "path to an .html file to host").option("--html <html>", "inline HTML body (alternative to --file)").option("--publish", "publish immediately instead of saving as draft").action(async (options, command) => {
+  pages.command("create").description("Create a hosted page from an HTML file or inline HTML").requiredOption("--slug <slug>", "public URL slug (served at /page/<slug>)").requiredOption("--title <title>", "page title").option("--file <path>", "path to an .html file to host").option("--html <html>", "inline HTML body (alternative to --file)").option("--publish", "publish immediately instead of saving as draft").option(
+    "--allow-placeholders",
+    "with --publish: publish even though the page still shows [UZUPE\u0141NIJ: \u2026] placeholders"
+  ).action(async (options, command) => {
     const flags = getGlobalFlags(command);
     const html = await resolveHtml2(options);
     if (!html) {
@@ -26944,10 +28665,15 @@ function registerPagesCommands(program2) {
       slug: options.slug,
       title: options.title,
       html,
-      publish: options.publish ?? false
+      publish: options.publish ?? false,
+      ...options.allowPlaceholders ? { allowPlaceholders: true } : {}
     };
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
-    const result = await client.createPage(input);
+    const result = await client.createPage(input).catch(
+      pointPlaceholderRefusalAtFlag(
+        "Fill them in, create it as a draft (without --publish), or re-run with --allow-placeholders to publish anyway."
+      )
+    );
     emit(flags, result, () => {
       process.stdout.write(`Created page ${result.pageId} \u2014 /${result.slug}
 `);
@@ -26997,14 +28723,26 @@ function registerPagesCommands(program2) {
     });
   });
   const publishCommand = (verb, publish, description) => {
-    pages.command(verb).description(description).argument("<id>", "page id").option("--only-this-page", "change this page only, not its companions or site pages").option("--dry-run", "list the pages that would change; change nothing").action(
+    const verbCommand = pages.command(verb).description(description).argument("<id>", "page id").option("--only-this-page", "change this page only, not its companions or site pages").option("--dry-run", "list the pages that would change; change nothing");
+    if (publish) {
+      verbCommand.option(
+        "--allow-placeholders",
+        "publish even though pages still show [UZUPE\u0141NIJ: \u2026] placeholders"
+      );
+    }
+    verbCommand.action(
       async (id, options, command) => {
         const flags = getGlobalFlags(command);
         const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
         const result = await client.publishPage(id, publish, {
           ...options.onlyThisPage ? { scope: "page" } : {},
-          ...options.dryRun ? { dryRun: true } : {}
-        });
+          ...options.dryRun ? { dryRun: true } : {},
+          ...options.allowPlaceholders ? { allowPlaceholders: true } : {}
+        }).catch(
+          pointPlaceholderRefusalAtFlag(
+            "Fill them in (pages update), or re-run with --allow-placeholders to publish anyway."
+          )
+        );
         emit(flags, result, () => {
           if (!result.dryRun) {
             process.stdout.write(`Page ${result.pageId} is now ${result.status}
@@ -27165,7 +28903,7 @@ function registerPagesCommands(program2) {
     });
   });
   pages.command("restore").description(
-    "Roll a page's HTML back to a revision. The current HTML is snapshotted first (source `restore`), so a restore is itself undoable. Requires --confirm."
+    "Roll a page's HTML back to a revision. The current HTML is snapshotted first (source `restore`), so a restore is itself undoable. On a published page a revision with a buy button that leads nowhere is refused (409, nothing restored). Requires --confirm."
   ).argument("<pageId>", "page id").argument("<revisionId>", "revision id from `pages revisions`").option("--confirm", "required \u2014 acknowledge that the current HTML will be replaced").action(
     async (pageId, revisionId, options, command) => {
       const flags = getGlobalFlags(command);
@@ -27229,6 +28967,11 @@ function registerPagesCommands(program2) {
 import { readFileSync as readFileSync22 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
 import { basename as basename2 } from "path";
+function parseBuyerFiles(value) {
+  if (value === "on") return true;
+  if (value === "off") return false;
+  throw new Error(`Invalid --buyer-files: ${value} (expected on | off)`);
+}
 var KB_TREE_CHANGED_ERROR = "tree-changed";
 var JSON_FLAG_HINT3 = "(write it as --json=<value> \u2014 a bare --json is the global JSON-output flag)";
 var PRODUCT_TYPE_INPUTS = [
@@ -27342,7 +29085,7 @@ function assertIsoDate2(value, flag) {
   }
   return value;
 }
-function assertOneOf3(value, allowed, flag) {
+function assertOneOf4(value, allowed, flag) {
   if (!allowed.includes(value)) {
     throw new Error(`Invalid ${flag}: ${value}. Use one of: ${allowed.join(", ")}`);
   }
@@ -27403,7 +29146,7 @@ function printAddedFiles(inputCount, result) {
   );
   printFilesTable(result.files);
 }
-function registerProductsCommands(program2) {
+function registerProductsCommands2(program2) {
   const products2 = program2.command("products").description("Manage products");
   products2.command("list").description("List products in the workspace").action(async (_, command) => {
     const flags = getGlobalFlags(command);
@@ -27441,6 +29184,10 @@ function registerProductsCommands(program2) {
       }
       if (product.language !== void 0) {
         process.stdout.write(`  Language: ${product.language ?? "none (platform language)"}
+`);
+      }
+      if (product.fileSetEnabled !== void 0) {
+        process.stdout.write(`  Files for buyers: ${product.fileSetEnabled ? "on" : "off"}
 `);
       }
       process.stdout.write(`  Clients: ${product.clientCount}
@@ -27534,7 +29281,9 @@ function registerProductsCommands(program2) {
       });
     }
   );
-  products2.command("update").description("Update a product's name, description, storefront visibility and/or language").argument("<id>", "product id").option("--name <name>", "new product name").option("--description <description>", "new product description").option(
+  products2.command("update").description(
+    "Update a product's name, description, storefront visibility, language and/or files for buyers"
+  ).argument("<id>", "product id").option("--name <name>", "new product name").option("--description <description>", "new product description").option(
     "--visibility <public|unlisted|private>",
     "where buyers find it once published: public (store + product page), unlisted (product page by link only), private (checkout links only)",
     parseStorefrontVisibility
@@ -27542,11 +29291,15 @@ function registerProductsCommands(program2) {
     "--language <pl|en|none>",
     "the product's language (buyer-facing pages and e-mails); none clears it (the platform's language applies)",
     parseProductLanguageOrNone
+  ).option(
+    "--buyer-files <on|off>",
+    "\u201EPliki dla kupuj\u0105cych\u201D: on opens the product's file set (\u201EPliki\u201D, `files push`) to its buyers, off hides it from them (the files stay saved)",
+    parseBuyerFiles
   ).action(
     async (id, options, command) => {
-      if (options.name === void 0 && options.description === void 0 && options.visibility === void 0 && options.language === void 0) {
+      if (options.name === void 0 && options.description === void 0 && options.visibility === void 0 && options.language === void 0 && options.buyerFiles === void 0) {
         throw new Error(
-          "Nothing to update: pass --name, --description, --visibility and/or --language."
+          "Nothing to update: pass --name, --description, --visibility, --language and/or --buyer-files."
         );
       }
       const flags = getGlobalFlags(command);
@@ -27555,7 +29308,8 @@ function registerProductsCommands(program2) {
         name: options.name,
         description: options.description,
         storefrontVisibility: options.visibility,
-        language: options.language === PRODUCT_LANGUAGE_NONE ? null : options.language
+        language: options.language === PRODUCT_LANGUAGE_NONE ? null : options.language,
+        fileSetEnabled: options.buyerFiles
       });
       emit(flags, result, () => {
         process.stdout.write(`Updated product ${result.productId}
@@ -27592,6 +29346,23 @@ function registerProductsCommands(program2) {
       }
     });
   });
+  products2.command("duplicate").description(
+    "Copy a product as a DRAFT (settings, offers with new prices, content) in a background run; community / knowledge base / newsletter are refused (422). Requires --confirm"
+  ).argument("<id>", "product id").option("--name <name>", 'name of the copy (default: "<name> (kopia)" / "(copy)")').option("--confirm", "required \u2014 acknowledge a new draft product is created").action(async (id, options, command) => {
+    requireConfirm(options.confirm, `duplicate product ${id}`);
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.duplicateProduct(id, options.name);
+    emit(
+      flags,
+      result,
+      () => process.stdout.write(
+        result.status === "already-running" ? `Product ${id} is already being copied (run ${result.runId}); no second copy.
+` : `Copying product ${id}${result.productId ? ` into ${result.productId}` : ""} (run ${result.runId}); the draft appears in \`products list\` when the run completes.
+`
+      )
+    );
+  });
   products2.command("publish").description("Publish a product (status \u2192 published; live for customers)").argument("<id>", "product id").action(async (id, _, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
@@ -27849,10 +29620,10 @@ function registerProductsCommands(program2) {
   ).option("--delivery-time <n>", "service: delivery time value").option("--delivery-unit <unit>", `service: ${DELIVERY_UNITS.join("|")} (with --delivery-time)`).option("--revision-rounds <n|unlimited>", 'service: revision rounds count or "unlimited"').option("--brief-method <method>", `service: ${BRIEF_METHODS.join("|")}`).option("--brief-url <url>", "service: external brief/intake form URL").option("--event-mode <mode>", `event: ${EVENT_MODES3.join("|")}`).option("--starts <iso>", "event: start (ISO 8601)").option("--ends <iso>", "event: end (ISO 8601)").option("--capacity <n>", "event: attendee capacity").option("--show-on-success <on|off>", "show the post-purchase CTA on the success page").action(
     async (productId, options, command) => {
       const flags = getGlobalFlags(command);
-      const bookingMethod = options.bookingMethod !== void 0 ? assertOneOf3(options.bookingMethod, BOOKING_METHODS, "--booking-method") : void 0;
-      const briefMethod = options.briefMethod !== void 0 ? assertOneOf3(options.briefMethod, BRIEF_METHODS, "--brief-method") : void 0;
-      const deliveryUnit = options.deliveryUnit !== void 0 ? assertOneOf3(options.deliveryUnit, DELIVERY_UNITS, "--delivery-unit") : void 0;
-      const eventMode = options.eventMode !== void 0 ? assertOneOf3(options.eventMode, EVENT_MODES3, "--event-mode") : void 0;
+      const bookingMethod = options.bookingMethod !== void 0 ? assertOneOf4(options.bookingMethod, BOOKING_METHODS, "--booking-method") : void 0;
+      const briefMethod = options.briefMethod !== void 0 ? assertOneOf4(options.briefMethod, BRIEF_METHODS, "--brief-method") : void 0;
+      const deliveryUnit = options.deliveryUnit !== void 0 ? assertOneOf4(options.deliveryUnit, DELIVERY_UNITS, "--delivery-unit") : void 0;
+      const eventMode = options.eventMode !== void 0 ? assertOneOf4(options.eventMode, EVENT_MODES3, "--event-mode") : void 0;
       if (options.deliveryTime === void 0 !== (options.deliveryUnit === void 0)) {
         throw new Error("Pass --delivery-time and --delivery-unit together.");
       }
@@ -27984,7 +29755,7 @@ function registerProductsCommands(program2) {
   ).option("--thank-you-type <type>", `${THANK_YOU_TYPES.join("|")}`).option("--redirect-url <url>", "redirect destination (implies --thank-you-type redirect)").option("--email-buyer-purchase <on|off>", "send the buyer a purchase confirmation email").option("--notify-owner-purchase <on|off>", "notify the owner of a purchase").option("--email-buyer-failed <on|off>", "email the buyer on a failed payment").option("--notify-owner-failed <on|off>", "notify the owner of a failed payment").action(
     async (productId, options, command) => {
       const flags = getGlobalFlags(command);
-      const thankYouType = options.thankYouType !== void 0 ? assertOneOf3(options.thankYouType, THANK_YOU_TYPES, "--thank-you-type") : void 0;
+      const thankYouType = options.thankYouType !== void 0 ? assertOneOf4(options.thankYouType, THANK_YOU_TYPES, "--thank-you-type") : void 0;
       if (options.redirectUrl !== void 0)
         assertHttpsUrl(options.redirectUrl, "--redirect-url");
       const emailBuyerPurchase = options.emailBuyerPurchase !== void 0 ? parseBool4(options.emailBuyerPurchase, "--email-buyer-purchase") : void 0;
@@ -28282,7 +30053,7 @@ function registerProductsCommands(program2) {
         title: options.title,
         parentId: options.category,
         editorContent: resolveKbContent(options),
-        status: options.status !== void 0 ? assertOneOf3(options.status, KB_ARTICLE_STATUSES, "--status") : void 0,
+        status: options.status !== void 0 ? assertOneOf4(options.status, KB_ARTICLE_STATUSES, "--status") : void 0,
         tags: options.tags !== void 0 ? parseKbTags(options.tags) : void 0
       });
       emit(flags, result, () => {
@@ -28320,7 +30091,7 @@ function registerProductsCommands(program2) {
       const result = await client.updateKbArticle(productId, articleId, {
         title: options.title,
         editorContent,
-        status: options.status !== void 0 ? assertOneOf3(options.status, KB_ARTICLE_STATUSES, "--status") : void 0,
+        status: options.status !== void 0 ? assertOneOf4(options.status, KB_ARTICLE_STATUSES, "--status") : void 0,
         parentId: options.category,
         coverImage,
         tags
@@ -29084,6 +30855,12 @@ function registerSegmentsCommands(program2) {
   withConditionOptions(
     segments.command("preview").description(
       "Count the clients matching a condition set WITHOUT saving anything (stateless dry run)"
+    ).option(
+      "--email-sendable",
+      "count only clients an e-mail campaign may mail (subscribed): the reach of a send"
+    ).option(
+      "--sms-sendable",
+      "count only clients an SMS campaign may text (SMS consent AND a phone): size an SMS send"
     )
   ).action(async (options, command) => {
     const flags = getGlobalFlags(command);
@@ -29091,12 +30868,20 @@ function registerSegmentsCommands(program2) {
     if (conditions === void 0) {
       throw new Error(`Pass at least one condition: ${CONDITION_FLAGS_HELP}.`);
     }
+    if (options.emailSendable && options.smsSendable) {
+      throw new Error("Pass either --email-sendable or --sms-sendable, not both.");
+    }
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
-    const result = await client.previewAudienceSegment(conditions);
+    const result = await client.previewAudienceSegment(conditions, {
+      requireSendable: options.emailSendable === true,
+      requireSmsSendable: options.smsSendable === true
+    });
     emit(flags, result, () => {
+      const count2 = result.partial ? `\u2265 ${result.count}` : String(result.count);
+      const reach = options.smsSendable ? " (SMS reach)" : options.emailSendable ? " (e-mail reach)" : "";
       process.stdout.write(
-        `${result.count} client${result.count === 1 ? " matches" : "s match"} ${conditions.map(describeCondition).join(" AND ")}.
-`
+        `${count2} client${result.count === 1 && !result.partial ? " matches" : "s match"} ${conditions.map(describeCondition).join(" AND ")}${reach}.
+` + (result.partial ? "The client base was not counted to the end in time: the real number may be higher.\n" : "")
       );
     });
   });
@@ -29104,6 +30889,157 @@ function registerSegmentsCommands(program2) {
 
 // src/commands/site/index.ts
 import { existsSync as existsSync4, readFileSync as readFileSync25 } from "fs";
+
+// src/commands/site/librarySections.ts
+var NO_SECTION = "none";
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function toSectionDrafts(rows) {
+  return rows.map((row, index) => {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new Error(`--sections[${index}] must be an object {id?, name, productIds}.`);
+    }
+    const name = "name" in row ? row.name : void 0;
+    const productIds = "productIds" in row ? row.productIds : [];
+    const id = "id" in row ? row.id : void 0;
+    if (typeof name !== "string") throw new Error(`--sections[${index}].name must be a string.`);
+    if (!isStringArray(productIds)) {
+      throw new Error(`--sections[${index}].productIds must be an array of product ids.`);
+    }
+    if (id !== void 0 && id !== null && typeof id !== "string") {
+      throw new Error(`--sections[${index}].id must be a section id or null.`);
+    }
+    return { ...typeof id === "string" ? { id } : {}, name, productIds };
+  });
+}
+function printSectionsView(result) {
+  printTable(
+    result.sections.map((section) => ({
+      id: section.id,
+      name: section.name,
+      products: section.products.map((product) => product.name).join(", ")
+    })),
+    ["id", "name", "products"]
+  );
+  if (result.unassignedProducts.length > 0) {
+    process.stdout.write(
+      `
+Pozosta\u0142e (no section): ${result.unassignedProducts.map((product) => product.name).join(", ")}
+`
+    );
+  }
+}
+function printStoredSections(result, done) {
+  process.stdout.write(`${done}
+`);
+  printTable(
+    result.sections.map((section) => ({
+      id: section.id,
+      name: section.name,
+      products: section.productIds.length
+    })),
+    ["id", "name", "products"]
+  );
+  if (result.droppedProductIds.length > 0) {
+    process.stdout.write(
+      `\u26A0\uFE0F Not stored (unknown, deleted or a bundle): ${result.droppedProductIds.join(", ")}
+`
+    );
+  }
+}
+function registerSiteLibrarySectionsCommands(site) {
+  const sections = site.command("library-sections").description(
+    "Sections of the member library (\u201EKrok 1\u201D, \u201EBonusy\u201D): a heading + a filter pill each; products in no section show under \u201EPozosta\u0142e\u201D. Products only, never bundles"
+  );
+  sections.command("list").description("The sections in display order with their products, and the unassigned products").action(async (_options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.listLibrarySections();
+    emit(flags, result, () => printSectionsView(result));
+  });
+  sections.command("create").description("Add a section (last by default); listed products move into it from any other").requiredOption("--name <name>", "heading + pill label, unique in the workspace").option("--products <a,b,...>", "product ids to put in it", parseCommaList("--products")).option(
+    "--position <n>",
+    "0-based place among the sections (default: last)",
+    parseNumberOption("--position", NumberFormat.Integer)
+  ).option("--confirm", "required \u2014 acknowledge the change of the member library").action(
+    async (options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm(options.confirm, "add a section to the member library");
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.createLibrarySection({
+        name: options.name,
+        ...options.products !== void 0 ? { productIds: options.products } : {},
+        ...options.position !== void 0 ? { position: options.position } : {}
+      });
+      emit(
+        flags,
+        result,
+        () => printStoredSections(result, `Created section ${result.sectionId ?? ""}.`)
+      );
+    }
+  );
+  sections.command("rename").description("Rename a section (its id and products stay)").argument("<sectionId>", "section id (`libsec_\u2026` from `site library-sections list`)").requiredOption("--name <name>", "the new heading").option("--confirm", "required \u2014 acknowledge the change of the member library").action(
+    async (sectionId, options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm(options.confirm, `rename section ${sectionId}`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.renameLibrarySection(sectionId, options.name);
+      emit(flags, result, () => printStoredSections(result, `Renamed section ${sectionId}.`));
+    }
+  );
+  sections.command("reorder").description("Set the section order \u2014 pass EVERY section id once, top first").argument("<sectionIds...>", "section ids in the new order").option("--confirm", "required \u2014 acknowledge the change of the member library").action(async (sectionIds, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, "reorder the library sections");
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.reorderLibrarySections(sectionIds);
+    emit(flags, result, () => printStoredSections(result, "Reordered the sections."));
+  });
+  sections.command("move").description("Move products into a section (they leave any other), or to none (\u201EPozosta\u0142e\u201D)").argument("<productIds...>", "product ids").requiredOption("--to <sectionId|none>", `target section id, or "${NO_SECTION}"`).option("--confirm", "required \u2014 acknowledge the change of the member library").action(
+    async (productIds, options, command) => {
+      const flags = getGlobalFlags(command);
+      const sectionId = options.to.trim().toLowerCase() === NO_SECTION ? null : options.to;
+      requireConfirm(options.confirm, "move products between library sections");
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.moveLibraryProducts(productIds, sectionId);
+      emit(
+        flags,
+        result,
+        () => printStoredSections(
+          result,
+          `Moved ${productIds.length} product(s) to ${sectionId ?? "no section"}.`
+        )
+      );
+    }
+  );
+  sections.command("replace").description(
+    "Full replace of the ordered list \u2014 sections left out are DELETED (their products go to \u201EPozosta\u0142e\u201D); keep a section by sending its id"
+  ).requiredOption(
+    "--sections <json|file>",
+    "JSON array of {id?, name, productIds} (read the current list with `--json site library-sections list`)",
+    parseJsonArrayFileOrInline("--sections")
+  ).option("--confirm", "required \u2014 acknowledge the full replace").action(async (options, command) => {
+    const flags = getGlobalFlags(command);
+    const drafts = toSectionDrafts(options.sections);
+    requireConfirm(options.confirm, "replace every library section");
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.replaceLibrarySections(drafts);
+    emit(
+      flags,
+      result,
+      () => printStoredSections(result, `Stored ${result.sections.length} section(s).`)
+    );
+  });
+  sections.command("delete").description("Delete a section; its products go back to \u201EPozosta\u0142e\u201D (no product is deleted)").argument("<sectionId>", "section id").option("--confirm", "required \u2014 acknowledge the deletion of the section").action(async (sectionId, options, command) => {
+    const flags = getGlobalFlags(command);
+    requireConfirm(options.confirm, `delete library section ${sectionId}`);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.deleteLibrarySection(sectionId);
+    emit(flags, result, () => printStoredSections(result, `Deleted section ${sectionId}.`));
+  });
+}
+
+// src/commands/site/index.ts
 var MAIN_PAGE_MODES = {
   sales: "/",
   dashboard: "/dashboard",
@@ -29149,7 +31085,7 @@ function parseJsonObjectFileOrInline5(value, flag) {
 function baseBody(json) {
   return json === void 0 ? {} : parseJsonObjectFileOrInline5(json, "--json");
 }
-function parseOnOff4(value, flag) {
+function parseOnOff5(value, flag) {
   const v = value.trim().toLowerCase();
   if (v === "on" || v === "true") return true;
   if (v === "off" || v === "false") return false;
@@ -29276,16 +31212,16 @@ function printDomainResults(results) {
   }
 }
 function printLegalDocuments(docs) {
-  const preview = (content) => content === null || content === "" ? "" : `${content.length} chars${content.length > 60 ? ` \u2014 "${content.slice(0, 60).replace(/\s+/g, " ")}\u2026"` : ` \u2014 "${content}"`}`;
+  const preview2 = (content) => content === null || content === "" ? "" : `${content.length} chars${content.length > 60 ? ` \u2014 "${content.slice(0, 60).replace(/\s+/g, " ")}\u2026"` : ` \u2014 "${content}"`}`;
   printTable(
     [
       { field: "language", value: docs.language },
       { field: "termsUrl", value: docs.termsUrl },
       { field: "termsSlug", value: docs.termsSlug ?? "" },
-      { field: "termsContent", value: preview(docs.termsContent) },
+      { field: "termsContent", value: preview2(docs.termsContent) },
       { field: "privacyPolicyUrl", value: docs.privacyPolicyUrl },
       { field: "privacyPolicySlug", value: docs.privacyPolicySlug ?? "" },
-      { field: "privacyPolicyContent", value: preview(docs.privacyPolicyContent) }
+      { field: "privacyPolicyContent", value: preview2(docs.privacyPolicyContent) }
     ],
     ["field", "value"]
   );
@@ -29386,9 +31322,12 @@ function registerSiteCommands2(program2) {
   ).option(
     "--robots-rules <text>",
     String.raw`extra robots.txt lines (User-agent / Allow / Disallow / Crawl-delay); separate lines with \n, or use --json`
+  ).option(
+    "--llms-txt <text|file|none>",
+    "the site's own /llms.txt (Markdown, inline or a file path); none = back to the generated file"
   ).option("--language <pl|en|default>", "UI language of the public site").option("--show-page-title <on|off>", "render the page title in the header").option(
     "--json <fileOrJson>",
-    "inline JSON object or .json path \u2014 pageTitle, pageDescription, seoDescription, robotsTxtRules, showPageTitle, language, mainPage, mainPageId, mainPageCommunityId"
+    "inline JSON object or .json path \u2014 pageTitle, pageDescription, seoDescription, robotsTxtRules, llmsTxt, showPageTitle, language, mainPage, mainPageId, mainPageCommunityId"
   ).action(
     async (options, command) => {
       const flags = getGlobalFlags(command);
@@ -29399,13 +31338,19 @@ function registerSiteCommands2(program2) {
       if (options.robotsRules !== void 0) {
         body.robotsTxtRules = options.robotsRules.split(String.raw`\n`).join("\n");
       }
+      if (options.llmsTxt !== void 0) {
+        body.llmsTxt = options.llmsTxt.trim().toLowerCase() === "none" ? null : readMarkdownOrFile(options.llmsTxt);
+      }
       if (options.language !== void 0) {
         body.language = parseChoice7(options.language, PLATFORM_LANGUAGES, "--language");
       }
       if (options.showPageTitle !== void 0) {
-        body.showPageTitle = parseOnOff4(options.showPageTitle, "--show-page-title");
+        body.showPageTitle = parseOnOff5(options.showPageTitle, "--show-page-title");
       }
-      assertNonEmptyBody(body, "pass --title, --description, --language or --json=<patch>.");
+      assertNonEmptyBody(
+        body,
+        "pass --title, --description, --llms-txt, --language or --json=<patch>."
+      );
       const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
       const result = await client.updateSiteGeneral(body).catch(withMainPageHint);
       emit(flags, result, () => process.stdout.write(SECTION_UPDATED("general")));
@@ -29425,7 +31370,7 @@ function registerSiteCommands2(program2) {
       if (options.radius !== void 0) body.radius = options.radius;
       if (options.styleVariant !== void 0) body.styleVariant = options.styleVariant;
       if (options.fromBrand !== void 0) {
-        body.themeFromBrand = parseOnOff4(options.fromBrand, "--from-brand");
+        body.themeFromBrand = parseOnOff5(options.fromBrand, "--from-brand");
       }
       assertNonEmptyBody(body, "pass --theme, --radius, --from-brand \u2026 or --json=<patch>.");
       const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
@@ -29452,7 +31397,7 @@ function registerSiteCommands2(program2) {
         body.platformFaviconUrl = orNull6(options.faviconUrl);
       }
       if (options.hideBranding !== void 0) {
-        body.hideZanfiaBranding = parseOnOff4(options.hideBranding, "--hide-branding");
+        body.hideZanfiaBranding = parseOnOff5(options.hideBranding, "--hide-branding");
       }
       assertNonEmptyBody(
         body,
@@ -29497,7 +31442,7 @@ function registerSiteCommands2(program2) {
   update.command("privacy").description("Cookie-consent banner on the public site").option("--cookie-consent <on|off>", "show the cookie consent banner").option("--json <fileOrJson>", "inline JSON object or .json path \u2014 cookieConsentEnabled").action(async (options, command) => {
     const flags = getGlobalFlags(command);
     const base = baseBody(options.json);
-    const cookieConsentEnabled = options.cookieConsent !== void 0 ? parseOnOff4(options.cookieConsent, "--cookie-consent") : base.cookieConsentEnabled;
+    const cookieConsentEnabled = options.cookieConsent !== void 0 ? parseOnOff5(options.cookieConsent, "--cookie-consent") : base.cookieConsentEnabled;
     if (typeof cookieConsentEnabled !== "boolean") {
       throw new Error(
         'Pass --cookie-consent on|off (or a --json body with "cookieConsentEnabled").'
@@ -29564,14 +31509,14 @@ function registerSiteCommands2(program2) {
         if (options.libraryOrder === void 0) customization.libraryOrder = "custom";
       }
       if (options.groupByType !== void 0) {
-        customization.libraryGroupByType = parseOnOff4(options.groupByType, "--group-by-type");
+        customization.libraryGroupByType = parseOnOff5(options.groupByType, "--group-by-type");
       }
       if (options.defaultView !== void 0) customization.defaultView = options.defaultView;
       if (options.messages !== void 0) {
-        customization.messagesEnabled = parseOnOff4(options.messages, "--messages");
+        customization.messagesEnabled = parseOnOff5(options.messages, "--messages");
       }
       if (options.clientMessages !== void 0) {
-        customization.clientMessagesEnabled = parseOnOff4(
+        customization.clientMessagesEnabled = parseOnOff5(
           options.clientMessages,
           "--client-messages"
         );
@@ -29810,6 +31755,7 @@ function registerSiteCommands2(program2) {
       });
     }
   );
+  registerSiteLibrarySectionsCommands(site);
 }
 function printStorefront(config) {
   printTable(
@@ -30321,6 +32267,96 @@ Next page: --after ${response.nextCursor}`);
   });
 }
 
+// src/commands/social/insights.ts
+var HIDDEN = { hidden: true };
+function parsePrivacy(value) {
+  const privacy = YOUTUBE_PRIVACY_STATUSES.find(
+    (candidate) => candidate === value.trim().toLowerCase()
+  );
+  if (privacy === void 0) {
+    throw new Error(
+      `Invalid --privacy: ${value} (expected one of: ${YOUTUBE_PRIVACY_STATUSES.join(", ")})`
+    );
+  }
+  return privacy;
+}
+var formatNumber = (value) => value ?? "";
+function registerSocialInsightsCommands(social) {
+  social.command("weekly", HIDDEN).description(
+    "Studio \u201ETw\xF3j tydzie\u0144 w social media\u201D: last week's posts per account against your own median (top / bottom posts and signals in `--json`)"
+  ).action(async (_options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const report = await client.getSocialWeekReport();
+    emit(flags, report, () => {
+      process.stdout.write(`Week ${report.weekStart} \u2192 ${report.weekEnd}
+`);
+      printTable(
+        report.networks.map((network) => ({
+          network: network.network,
+          account: network.label,
+          state: network.state,
+          metric: network.metric ?? "",
+          median: formatNumber(network.baselineMedian),
+          postsThisWeek: network.postsThisWeek
+        })),
+        ["network", "account", "state", "metric", "median", "postsThisWeek"]
+      );
+    });
+  });
+  social.command("performance", HIDDEN).description(
+    "One Zanfia post's numbers per target against your median (\u201Eten post jeszcze \u017Cyje\u201D); the curve in `--json`"
+  ).argument("<postId>", "social post id (from `social posts`)").action(async (postId, _options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const performance = await client.getSocialPostPerformance(postId);
+    emit(
+      flags,
+      performance,
+      () => printTable(
+        performance.targets.map((target) => ({
+          target: target.target,
+          state: target.state,
+          metric: target.metric ?? "",
+          score: formatNumber(target.score),
+          median: formatNumber(target.baselineMedian),
+          publishedAt: target.publishedAt ?? ""
+        })),
+        ["target", "state", "metric", "score", "median", "publishedAt"]
+      )
+    );
+  });
+  const youtube = social.commands.find((command) => command.name() === "youtube") ?? social.command("youtube");
+  youtube.command("visibility", HIDDEN).description(
+    "Change the visibility of a post's published YouTube video (private / unlisted / public), or schedule its public release. Requires --confirm"
+  ).argument("<postId>", "the social post that published the video").requiredOption("--privacy <private|unlisted|public>", "the new visibility", parsePrivacy).option(
+    "--publish-at <iso>",
+    "public release time, ISO 8601 with an offset (only with --privacy private)"
+  ).option("--confirm", "required \u2014 acknowledge the change on YouTube").action(
+    async (postId, options, command) => {
+      const flags = getGlobalFlags(command);
+      if (options.publishAt !== void 0 && options.privacy !== "private") {
+        throw new Error("--publish-at needs --privacy private (YouTube makes it public then).");
+      }
+      requireConfirm(options.confirm, `change the YouTube visibility of post ${postId}`);
+      const input = {
+        privacyStatus: options.privacy,
+        ...options.publishAt !== void 0 ? { publishAt: options.publishAt } : {}
+      };
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.setYouTubeVideoVisibility(postId, input);
+      emit(
+        flags,
+        result,
+        () => process.stdout.write(
+          `Video ${result.videoId} is ${result.privacyStatus}${result.publishAt ? `, public from ${result.publishAt}` : ""}${result.demo ? " (demo: nothing was sent to YouTube)" : ""}.
+`
+        )
+      );
+    }
+  );
+}
+
 // src/commands/social/index.ts
 function updateInput(options) {
   const targets = splitList(options.targets);
@@ -30516,6 +32552,7 @@ function registerSocialCommands(program2) {
     });
   });
   registerSocialChannelCommands(social);
+  registerSocialInsightsCommands(social);
 }
 
 // src/commands/stats/index.ts
@@ -30928,6 +32965,148 @@ ${integration.name}: ${integration.healthExplanation}
   });
 }
 
+// src/commands/studio/drafts.ts
+import { readFileSync as readFileSync27 } from "fs";
+var TEXT_PREVIEW_LENGTH = 60;
+function parseWeakReason(value) {
+  const reason = STUDIO_SOCIAL_DRAFT_WEAK_REASONS.find(
+    (candidate) => candidate === value.trim().toLowerCase()
+  );
+  if (reason === void 0) {
+    throw new Error(
+      `Invalid --reason: ${value} (expected one of: ${STUDIO_SOCIAL_DRAFT_WEAK_REASONS.join(", ")})`
+    );
+  }
+  return reason;
+}
+var SINGLE_ACCOUNT_TARGETS = [
+  "instagram",
+  "linkedin",
+  "threads",
+  "youtube",
+  "tiktok",
+  "telegram"
+];
+function parseTarget(value) {
+  const target = value.trim();
+  const single = SINGLE_ACCOUNT_TARGETS.find((candidate) => candidate === target);
+  if (single !== void 0) return single;
+  const separator = target.indexOf(":");
+  const network = target.slice(0, separator);
+  const accountId = target.slice(separator + 1);
+  if (separator > 0 && accountId !== "") {
+    if (network === "facebook") return `facebook:${accountId}`;
+    if (network === "instagram") return `instagram:${accountId}`;
+  }
+  throw new Error(
+    `Invalid target: ${value} (expected ${SINGLE_ACCOUNT_TARGETS.join(", ")}, facebook:<pageId> or instagram:<accountId>; see \`social accounts\`)`
+  );
+}
+function preview(text) {
+  const oneLine2 = text.replace(/\s+/g, " ").trim();
+  return oneLine2.length > TEXT_PREVIEW_LENGTH ? `${oneLine2.slice(0, TEXT_PREVIEW_LENGTH)}\u2026` : oneLine2;
+}
+function printDrafts(accounts) {
+  const rows = accounts.flatMap(
+    (account) => account.drafts.map((draft) => ({
+      id: draft.id,
+      account: account.label,
+      slot: draft.slot,
+      status: draft.status,
+      text: preview(draft.text)
+    }))
+  );
+  printTable(rows, ["id", "account", "slot", "status", "text"]);
+  for (const account of accounts) {
+    process.stdout.write(`${account.label} (${account.target}): ${account.remaining} left
+`);
+  }
+}
+function registerStudioDraftsCommands(program2) {
+  const studio = program2.commands.find((command) => command.name() === "studio") ?? program2.command("studio");
+  const drafts = studio.command("drafts", { hidden: true }).description("This week's social post drafts in your voice (Studio \u201E5 szkic\xF3w\u201D)");
+  drafts.command("list").description("This week's drafts per connected account and how many each may still get").action(async (_options, command) => {
+    const flags = getGlobalFlags(command);
+    const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+    const result = await client.listStudioSocialDrafts();
+    emit(flags, result, () => {
+      process.stdout.write(`Week of ${result.week}
+`);
+      printDrafts(result.accounts);
+    });
+  });
+  drafts.command("generate").description(
+    "Write this week's drafts for one account; spends AI credits (402 when they are out)"
+  ).requiredOption("--target <target>", "the account target (from `social accounts`)", parseTarget).option("--topic <text>", "what the posts should be about").option("--language <pl|en>", "default: the workspace language").option("--confirm", "required \u2014 acknowledge the AI credits spent").action(
+    async (options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm(options.confirm, "spend AI credits on new drafts");
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.generateStudioSocialDrafts({
+        target: options.target,
+        ...options.topic !== void 0 ? { topic: options.topic } : {},
+        ...options.language !== void 0 ? { language: options.language } : {}
+      });
+      emit(flags, result, () => {
+        process.stdout.write(
+          `Wrote ${result.created} draft(s) for ${result.account.label}${result.rejectedByAiTells > 0 ? ` (${result.rejectedByAiTells} held back)` : ""}.
+`
+        );
+        printDrafts([result.account]);
+      });
+    }
+  );
+  drafts.command("feedback").description(
+    "Mark a draft \u201ES\u0142abe\u201D with a reason: it is hidden and the next drafts learn from it"
+  ).argument("<draftId>", "draft id (from `studio drafts list`)").requiredOption(
+    `--reason <${STUDIO_SOCIAL_DRAFT_WEAK_REASONS.join("|")}>`,
+    "why it is weak",
+    parseWeakReason
+  ).option("--confirm", "required \u2014 acknowledge the draft is hidden").action(
+    async (draftId, options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm(options.confirm, `mark draft ${draftId} as weak`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.sendStudioSocialDraftFeedback(draftId, options.reason);
+      emit(
+        flags,
+        result,
+        () => process.stdout.write(
+          `Draft ${draftId} is marked weak.${result.learnedRule ? ` Learned: ${result.learnedRule}` : ""}
+`
+        )
+      );
+    }
+  );
+  drafts.command("to-composer").description("Turn a draft into a DRAFT social post (nothing is published or scheduled)").argument("<draftId>", "draft id").option("--text <text>", "the edited text (default: the draft as written)").option("--text-file <path>", "read the edited text from a file").option(
+    "--targets <a,b,...>",
+    "accounts to post to (default: the draft's own account)",
+    parseCommaList("--targets")
+  ).option("--confirm", "required \u2014 acknowledge a draft post is created").action(
+    async (draftId, options, command) => {
+      const flags = getGlobalFlags(command);
+      if (options.text !== void 0 && options.textFile !== void 0) {
+        throw new Error("Use either --text or --text-file, not both.");
+      }
+      const text = options.textFile !== void 0 ? readFileSync27(options.textFile, "utf8") : options.text;
+      requireConfirm(options.confirm, `create a draft social post from ${draftId}`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.sendStudioSocialDraftToComposer(draftId, {
+        ...text !== void 0 ? { text } : {},
+        ...options.targets !== void 0 ? { targets: options.targets.map((target) => parseTarget(target)) } : {}
+      });
+      emit(
+        flags,
+        result,
+        () => process.stdout.write(
+          `Draft post ${result.socialPostId} is in Social \u203A Posty (nothing is published).
+`
+        )
+      );
+    }
+  );
+}
+
 // src/commands/subscriptions/index.ts
 function formatAmount4(amountMinor, currency) {
   return `${(amountMinor / 100).toFixed(2)} ${currency.toUpperCase()}`;
@@ -30965,7 +33144,7 @@ function describeRetryStatus(status) {
       return "Failed \u2014 the retry did not go through.";
   }
 }
-function registerSubscriptionsCommands(program2) {
+function registerSubscriptionsCommands2(program2) {
   const subscriptions = program2.command("subscriptions").description("Recurring billing: failed payments, manual renewals, subscriptions ending soon");
   subscriptions.command("failed").description(
     "Failed subscription / installment charges with live Stripe dunning state (attempts, next automatic retry, hosted invoice URL). Retry one with `subscriptions retry`"
@@ -31557,7 +33736,7 @@ Next page: --cursor ${page.nextCursor}
 }
 
 // src/commands/workflows/index.ts
-import { readFileSync as readFileSync27 } from "fs";
+import { readFileSync as readFileSync28 } from "fs";
 
 // src/commands/workflows/authoring.ts
 import { writeFileSync as writeFileSync6 } from "fs";
@@ -31740,7 +33919,7 @@ function requireConfirm17(confirm, what) {
 }
 function parseTriggerContext(value) {
   const trimmed = value.trim();
-  const raw = trimmed.startsWith("{") ? trimmed : readFileSync27(value, "utf8");
+  const raw = trimmed.startsWith("{") ? trimmed : readFileSync28(value, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -31809,7 +33988,9 @@ function registerWorkflowsCommands(program2) {
       printWorkflowGraphs(workflow, published, draft, templateNames);
     });
   });
-  workflows.command("runs").description("List recent runs of a workflow (newest first)").argument("<automationId>", "workflow automation id").option("--limit <n>", "number of runs to return (default 20, max 100)").action(async (automationId, options, command) => {
+  const runs = workflows.command("runs").description(
+    "List recent runs of a workflow (newest first); `workflows runs stop` takes one person out of a run"
+  ).argument("<automationId>", "workflow automation id").option("--limit <n>", "number of runs to return (default 20, max 100)").action(async (automationId, options, command) => {
     const flags = getGlobalFlags(command);
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
     const page = await client.listAutomationRuns(
@@ -31831,6 +34012,23 @@ function registerWorkflowsCommands(program2) {
       );
     });
   });
+  runs.command("stop").description(
+    "Take the person out of this run \u2014 it ends cancelled and nothing after the current step runs (a step already sending finishes). A finished run is left as it is. They can enter again when the trigger fires later. Requires --confirm"
+  ).argument("<automationId>", "workflow automation id").argument("<runId>", "run id (from `workflows runs` or `clients automation-runs list`)").option("--confirm", "required \u2014 acknowledge that the run ends for this person").action(
+    async (automationId, runId, options, command) => {
+      const flags = getGlobalFlags(command);
+      requireConfirm17(options.confirm, `stop run ${runId} (no further steps for this person)`);
+      const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
+      const result = await client.stopAutomationRun(automationId, runId);
+      emit(flags, result, () => {
+        process.stdout.write(
+          result.stopped.length > 0 ? `Stopped run ${runId} of workflow ${automationId}.
+` : `Run ${runId} had already finished \u2014 nothing to stop.
+`
+        );
+      });
+    }
+  );
   workflows.command("pause").description(
     "Pause a workflow \u2014 it stops reacting to its trigger events AND cancels runs that are in progress or waiting in a delay (those contacts get no further steps)"
   ).argument("<automationId>", "workflow automation id").action(async (automationId, _, command) => {
@@ -31846,13 +34044,36 @@ function registerWorkflowsCommands(program2) {
   });
   workflows.command("resume").description(
     "Resume a paused workflow (requires a published version \u2014 a never-published draft cannot run)"
-  ).argument("<automationId>", "workflow automation id").action(async (automationId, _, command) => {
+  ).argument("<automationId>", "workflow automation id").option(
+    "--held-events <decision>",
+    "a webhook paused after failed deliveries holds the events that reached it (14 days each): `send` delivers them (30 a minute; a failure pauses it again and the rest wait), `skip` drops them. Without it such a resume is refused with the count."
+  ).action(async (automationId, options, command) => {
     const flags = getGlobalFlags(command);
+    const heldEvents = HELD_EVENTS_DECISIONS.find((value) => value === options.heldEvents);
+    if (options.heldEvents !== void 0 && !heldEvents) {
+      throw new ApiError(0, "--held-events must be `send` or `skip`");
+    }
     const client = createApiClient({ apiKey: flags.apiKey, verbose: flags.verbose });
-    const result = await client.setAutomationStatus(automationId, "active");
+    const result = await client.setAutomationStatus(automationId, "active", heldEvents).catch((error) => {
+      if (error instanceof ApiError && error.status === 409 && !heldEvents) {
+        throw new ApiError(
+          409,
+          error.apiMessage,
+          "Run again with --held-events send (deliver them) or --held-events skip (drop them)."
+        );
+      }
+      throw error;
+    });
     emit(flags, result, () => {
       process.stdout.write(`Resumed workflow ${result.id}.
 `);
+      if (result.heldEvents) {
+        process.stdout.write(
+          result.heldEvents.decision === "send" ? `${result.heldEvents.count} held event(s) are being sent, 30 a minute.
+` : `${result.heldEvents.count} held event(s) were dropped.
+`
+        );
+      }
     });
   });
   workflows.command("retry").description(
@@ -32269,7 +34490,7 @@ function describeDelay(config) {
       return `wait until ${optionalString(config.date) ?? "?"}${optionalString(config.timezone) ? ` (${config.timezone})` : ""}`;
     case "untilContextDate": {
       const offset = typeof config.offsetMinutes === "number" ? config.offsetMinutes : 0;
-      return `wait until ${optionalString(config.contextKey) ?? "?"}${offset !== 0 ? ` ${offset > 0 ? "+" : ""}${offset} min` : ""}${config.skipWhenPast === true ? " (skip branch when past)" : ""}`;
+      return `wait until ${optionalString(config.contextKey) ?? "?"}${offset !== 0 ? ` ${offset > 0 ? "+" : ""}${offset} min` : ""}${config.skipWhenPast === true ? config.skipToNextWait === true ? " (skip to the next wait when past)" : " (skip branch when past)" : ""}`;
     }
     default:
       return `wait (${mode})`;
@@ -32324,7 +34545,7 @@ function printLogins(profiles) {
     "\n* = active. Switch: `zanfia workspace use <id|slug>`; one command: `--workspace <id|slug>`.\n"
   );
 }
-function parseOnOff5(value, flag) {
+function parseOnOff6(value, flag) {
   const match = ["on", "off"].find((v) => v === value);
   if (!match) throw new Error(`Invalid ${flag}: ${value} (expected on | off)`);
   return match === "on";
@@ -32407,7 +34628,7 @@ function registerWorkspaceCommands(program2) {
       }
       if (options.inheritTimezone) input.timezone = null;
       if (options.autoTranscribe !== void 0) {
-        input.autoTranscribeUploads = parseOnOff5(options.autoTranscribe, "--auto-transcribe");
+        input.autoTranscribeUploads = parseOnOff6(options.autoTranscribe, "--auto-transcribe");
       }
       if (options.transcriptionLanguage !== void 0) {
         input.transcriptionLanguage = parseTranscriptionLanguage(options.transcriptionLanguage);
@@ -32478,11 +34699,11 @@ function applyShortHelp(program2) {
 
 // src/program.ts
 function resolveCliVersion() {
-  if ("0.21.0".length > 0) {
-    return "0.21.0";
+  if ("0.23.0".length > 0) {
+    return "0.23.0";
   }
   try {
-    const raw = readFileSync28(new URL("../package.json", import.meta.url), "utf8");
+    const raw = readFileSync29(new URL("../package.json", import.meta.url), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && "version" in parsed) {
       const { version: version2 } = parsed;
@@ -32523,7 +34744,7 @@ Signing in \u2014 two roles, two consent pages:
   registerJoinCommand(program2);
   registerLogoutCommand(program2);
   registerAuthCommands(program2);
-  registerProductsCommands(program2);
+  registerProductsCommands2(program2);
   registerOffersCommands(program2);
   registerCheckoutSettingsCommands(program2);
   registerIntegrationsCommands(program2);
@@ -32532,7 +34753,7 @@ Signing in \u2014 two roles, two consent pages:
   registerOtoCommands(program2);
   registerBumpsCommands(program2);
   registerCoursesCommands(program2);
-  registerGeneratedCommands(program2);
+  registerConsultationsCommands(program2);
   registerNewslettersCommands(program2);
   registerCommunitiesCommands(program2);
   registerConversationsCommands(program2);
@@ -32545,8 +34766,8 @@ Signing in \u2014 two roles, two consent pages:
   registerTestimonialsCommands(program2);
   registerBrandCommands(program2);
   registerTeamCommands(program2);
-  registerOrdersCommands(program2);
-  registerSubscriptionsCommands(program2);
+  registerOrdersCommands2(program2);
+  registerSubscriptionsCommands2(program2);
   registerStatsCommands(program2);
   registerDiscountsCommands(program2);
   registerReferralsCommands(program2);
@@ -32558,6 +34779,8 @@ Signing in \u2014 two roles, two consent pages:
   registerSocialCommands(program2);
   registerMediaCommands(program2);
   registerFilesCommands(program2);
+  registerStudioDraftsCommands(program2);
+  registerGeneratedCommands(program2);
   applyGlobalOptions(program2);
   applyShortHelp(program2);
   return program2;