maeve-cli 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { pathToFileURL } from "url";
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import { fileURLToPath } from "url";
 import { Command } from "commander";
 
 // src/commands/analytics.ts
@@ -42,7 +42,7 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync }
 import { homedir } from "os";
 import { dirname, join } from "path";
 function getCredentialFilePath(env = process.env, platform = process.platform) {
-  const override = env.MAEVE_CLI_AUTH_FILE ?? env.EZIBREEZY_CLI_AUTH_FILE;
+  const override = env.MAEVE_CLI_AUTH_FILE;
   if (override) return override;
   if (platform === "win32") {
     return join(env.APPDATA || join(homedir(), "AppData", "Roaming"), "Maeve", "cli-auth.json");
@@ -52,30 +52,6 @@ function getCredentialFilePath(env = process.env, platform = process.platform) {
   }
   return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "maeve", "cli-auth.json");
 }
-function getLegacyCredentialFilePath(env = process.env, platform = process.platform) {
-  if (env.MAEVE_CLI_AUTH_FILE ?? env.EZIBREEZY_CLI_AUTH_FILE) return void 0;
-  if (platform === "win32") {
-    return join(env.APPDATA || join(homedir(), "AppData", "Roaming"), "EziBreezy", "cli-auth.json");
-  }
-  if (platform === "darwin") {
-    return join(homedir(), "Library", "Application Support", "EziBreezy", "cli-auth.json");
-  }
-  return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "ezibreezy", "cli-auth.json");
-}
-function migrateLegacyCredentialFile(env = process.env, platform = process.platform) {
-  const legacyPath = getLegacyCredentialFilePath(env, platform);
-  if (!legacyPath) return;
-  const targetPath = getCredentialFilePath(env, platform);
-  if (targetPath === legacyPath) return;
-  if (existsSync(targetPath) || !existsSync(legacyPath)) return;
-  try {
-    mkdirSync(dirname(targetPath), { recursive: true });
-    writeFileSync(targetPath, readFileSync(legacyPath, "utf8"), { mode: 384 });
-    restrictCredentialFilePermissions(targetPath);
-    rmSync(legacyPath, { force: true });
-  } catch {
-  }
-}
 function readCredentialFile(filePath = getCredentialFilePath()) {
   if (!existsSync(filePath)) return { profiles: {} };
   try {
@@ -512,7 +488,10 @@ function registerAnalyticsCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("analytics:report")).description("Generate an agency-plan analytics PDF report.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--provider <provider>", "Report provider: instagram, facebook, youtube, tiktok, pinterest, or threads.").requiredOption("--json <file>", "JSON file containing report integration IDs and report options.").requiredOption("--output <file>", "PDF output file.").option("--yes", "Confirm report generation.").action(
+  addConnectionOptions(program.command("analytics:report")).description("Generate an team-plan analytics PDF report.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption(
+    "--provider <provider>",
+    "Report provider: instagram, facebook, youtube, tiktok, pinterest, or threads."
+  ).requiredOption("--json <file>", "JSON file containing report integration IDs and report options.").requiredOption("--output <file>", "PDF output file.").option("--yes", "Confirm report generation.").action(
     async (options, command) => {
       if (!options.yes) {
         throw new CliError("analytics:report requires --yes because PDF generation can be expensive.", {
@@ -714,16 +693,222 @@ function registerAuthCommands(program) {
   });
 }
 
-// src/approval-schema.ts
+// src/commands/boosts.ts
+function registerBoostCommands(program) {
+  addConnectionOptions(program.command("boosts:list")).description("List boosts for a workspace. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--content-ids <ids>", "Comma-separated content IDs to filter by.").option("--statuses <statuses>", "Comma-separated statuses: creating, active, paused, completed, error.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/boosts`, {
+        query: { contentIds: options.contentIds, statuses: options.statuses }
+      })
+    );
+  });
+  addConnectionOptions(program.command("boosts:get")).description("Read one boost. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <boostId>", "Boost ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/boosts/${options.id}`));
+  });
+  addConnectionOptions(program.command("boosts:performance")).description("Refresh and read boost performance. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <boostId>", "Boost ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/boosts/${options.id}/performance`));
+  });
+  addConnectionOptions(program.command("boosts:ad-accounts")).description("List available Meta ad accounts for an integration. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("-i, --integration <id>", "Integration ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/boosts/ad-accounts/${options.integration}`)
+    );
+  });
+  addConnectionOptions(program.command("boosts:boosted-content-ids")).description("List active boosted content IDs. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--content-ids <ids>", "Comma-separated content IDs to filter by.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/boosts/boosted-content-ids`, {
+        query: { contentIds: options.contentIds }
+      })
+    );
+  });
+  addConnectionOptions(program.command("boosts:by-content")).description("Read the boost for one published content item. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--content <contentId>", "Published content ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/boosts/content/${options.content}`));
+  });
+}
+
+// src/campaign-schema.ts
 import { z as z2 } from "zod";
 var uuid2 = z2.string().uuid();
-var nonEmptyString = z2.string().min(1);
-var nullableString = z2.string().nullable().optional();
-var approvalPolicy = z2.enum(["any", "all"]);
-var workflowMode = z2.enum(["client", "internal_client"]);
-var attachmentContentType = z2.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]);
-var reviewLifecyclePhase = z2.enum(["none", "internal", "client"]);
-var reviewLifecycleState = z2.enum([
+var hexColor = z2.string().regex(/^#?(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, "Color must be a hex color, e.g. #2563EB.");
+var isoDate = z2.string().refine(
+  (value) => /^\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}(:\d{2}(\.\d+)?)?([Zz]|[+-]\d{2}:?\d{2})?)?$/.test(value) && !Number.isNaN(Date.parse(value)),
+  { message: "Must be an ISO 8601 date string, e.g. 2026-01-01 or 2026-01-01T00:00:00Z." }
+);
+var budgetAmount = z2.string().regex(/^\d+(\.\d{1,2})?$/, 'Budget must be a decimal string like "1000" or "1000.50".');
+var currencyCode = z2.string().regex(/^[A-Z]{3}$/, 'Currency must be a 3-letter ISO code like "USD".');
+var campaignBaseShape = {
+  name: z2.string().min(1).max(160),
+  color: hexColor.nullable().optional(),
+  goal: z2.string().max(500).nullable().optional(),
+  description: z2.string().max(2e4).nullable().optional(),
+  startDate: isoDate,
+  endDate: isoDate,
+  targetPlatforms: z2.array(z2.string()).max(50).optional(),
+  estimatedBudget: budgetAmount.nullable().optional(),
+  actualBudget: budgetAmount.nullable().optional(),
+  budgetCurrency: currencyCode.nullable().optional()
+};
+var createCampaignSchema = z2.object(campaignBaseShape).strict();
+var updateCampaignSchema = z2.object({
+  ...campaignBaseShape,
+  // The update DTO drops @IsNotEmpty on name and makes the dates optional.
+  name: z2.string().max(160).optional(),
+  startDate: isoDate.optional(),
+  endDate: isoDate.optional()
+}).strict().refine((payload) => Object.keys(payload).length > 0, {
+  message: "Campaign update payload must include at least one field."
+});
+var createCampaignPhaseSchema = z2.object({
+  name: z2.string().min(1).max(120),
+  color: hexColor.nullable().optional(),
+  startDate: isoDate.nullable().optional(),
+  endDate: isoDate.nullable().optional(),
+  sortOrder: z2.number().int().min(0).optional()
+}).strict();
+var updateCampaignPhaseSchema = z2.object({
+  name: z2.string().max(120).optional(),
+  color: hexColor.nullable().optional(),
+  startDate: isoDate.nullable().optional(),
+  endDate: isoDate.nullable().optional(),
+  sortOrder: z2.number().int().min(0).optional()
+}).strict().refine((payload) => Object.keys(payload).length > 0, {
+  message: "Campaign phase update payload must include at least one field."
+});
+var saveCampaignPhaseDraftSchema = z2.object({
+  id: uuid2.optional(),
+  name: z2.string().min(1).max(120),
+  color: hexColor.nullable().optional(),
+  startDate: isoDate.nullable().optional(),
+  endDate: isoDate.nullable().optional()
+}).strict();
+var saveCampaignPhasesSchema = z2.object({
+  phases: z2.array(saveCampaignPhaseDraftSchema).max(100)
+}).strict();
+
+// src/commands/campaigns.ts
+function registerCampaignCommands(program) {
+  addConnectionOptions(program.command("campaigns:list")).description("List campaigns for a workspace.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--search <text>", "Case-insensitive campaign name search.").option("--include-archived", "Include archived campaigns.").option("--include-phases", "Include campaign phases on each campaign.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/campaigns`, {
+        query: {
+          search: options.search,
+          includeArchived: options.includeArchived,
+          includePhases: options.includePhases
+        }
+      })
+    );
+  });
+  addConnectionOptions(program.command("campaigns:get")).description("Get one campaign.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/campaigns/${options.id}`));
+  });
+  addConnectionOptions(program.command("campaigns:content")).description("List compact content for one campaign.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").option("--limit <number>", "Maximum rows to return.").option("--offset <number>", "Rows to skip.").option("--phase <phaseId>", 'Phase ID, or "none" for content without a phase.').option("--status <status>", "Content status filter.").option("--platform <platform>", "Integration platform filter.").option("--sort-direction <direction>", "Primary date sort direction: asc or desc.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/campaigns/${options.id}/content`, {
+        query: {
+          limit: options.limit,
+          offset: options.offset,
+          phase: options.phase,
+          status: options.status,
+          platform: options.platform,
+          sortDirection: options.sortDirection
+        }
+      })
+    );
+  });
+  addConnectionOptions(program.command("campaigns:create")).description("Create a campaign from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing the campaign payload.").action(async (options, command) => {
+    const payload = createCampaignSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/campaigns`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("campaigns:update")).description("Update a campaign from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").requiredOption("--json <file>", "JSON file containing fields to update.").action(async (options, command) => {
+    const payload = updateCampaignSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("PATCH", `/v1/workspaces/${options.workspace}/campaigns/${options.id}`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("campaigns:archive")).description("Archive a campaign.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("POST", `/v1/workspaces/${options.workspace}/campaigns/${options.id}/archive`));
+  });
+  addConnectionOptions(program.command("campaigns:restore")).description("Restore an archived campaign.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("POST", `/v1/workspaces/${options.workspace}/campaigns/${options.id}/restore`));
+  });
+  addConnectionOptions(program.command("campaigns:phases:list")).description("List phases for one campaign.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/campaigns/${options.id}/phases`));
+  });
+  addConnectionOptions(program.command("campaigns:phases:create")).description("Create a campaign phase from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").requiredOption("--json <file>", "JSON file containing the campaign phase payload.").action(async (options, command) => {
+    const payload = createCampaignPhaseSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/campaigns/${options.id}/phases`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("campaigns:phases:replace")).description("Replace all phases for one campaign from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").requiredOption("--json <file>", "JSON file containing the complete phases array.").action(async (options, command) => {
+    const payload = saveCampaignPhasesSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("PUT", `/v1/workspaces/${options.workspace}/campaigns/${options.id}/phases`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("campaigns:phases:update")).description("Update one campaign phase from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").requiredOption("--phase-id <phaseId>", "Campaign phase ID.").requiredOption("--json <file>", "JSON file containing fields to update.").action(async (options, command) => {
+    const payload = updateCampaignPhaseSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request(
+        "PATCH",
+        `/v1/workspaces/${options.workspace}/campaigns/${options.id}/phases/${options.phaseId}`,
+        {
+          body: payload
+        }
+      )
+    );
+  });
+  addConnectionOptions(program.command("campaigns:phases:delete")).description("Delete one campaign phase.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <campaignId>", "Campaign ID.").requiredOption("--phase-id <phaseId>", "Campaign phase ID.").option("--yes", "Confirm deleting the campaign phase.").action(async (options, command) => {
+    if (!options.yes) {
+      throw new CliError("campaigns:phases:delete requires --yes because it permanently removes the phase.", {
+        code: "INVALID_OPTIONS"
+      });
+    }
+    const client = createApiClient(resolveConfig(command));
+    await client.request(
+      "DELETE",
+      `/v1/workspaces/${options.workspace}/campaigns/${options.id}/phases/${options.phaseId}`
+    );
+    writeJson({ campaignId: options.id, phaseId: options.phaseId, deleted: true });
+  });
+}
+
+// src/approval-schema.ts
+import { z as z3 } from "zod";
+var uuid3 = z3.string().uuid();
+var nonEmptyString = z3.string().min(1);
+var nullableString = z3.string().nullable().optional();
+var approvalPolicy = z3.enum(["any", "all"]);
+var workflowMode = z3.enum(["client", "internal_client"]);
+var attachmentContentType = z3.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+var reviewLifecyclePhase = z3.enum(["none", "internal", "client"]);
+var reviewLifecycleState = z3.enum([
   "none",
   "internal_review_pending",
   "internal_review_approved",
@@ -739,8 +924,8 @@ var reviewLifecycleState = z2.enum([
   "client_review_cancelled",
   "client_review_expired"
 ]);
-var reviewLifecycleActor = z2.enum(["none", "agency", "author", "approver", "client", "system"]);
-var reviewLifecycleNextAction = z2.enum([
+var reviewLifecycleActor = z3.enum(["none", "agency", "author", "approver", "client", "system"]);
+var reviewLifecycleNextAction = z3.enum([
   "none",
   "request_internal_approval",
   "complete_internal_review",
@@ -754,7 +939,7 @@ var reviewLifecycleNextAction = z2.enum([
   "publish",
   "set_intended_publish_time"
 ]);
-var reviewLifecycleBlockerCode = z2.enum([
+var reviewLifecycleBlockerCode = z3.enum([
   "missing_schedule",
   "internal_approval_pending",
   "internal_changes_requested",
@@ -767,49 +952,49 @@ var reviewLifecycleBlockerCode = z2.enum([
   "missing_review_snapshot",
   "review_snapshot_hash_mismatch"
 ]);
-var reviewLifecycleSharedVersionStatus = z2.enum([
+var reviewLifecycleSharedVersionStatus = z3.enum([
   "not_shared",
   "current",
   "stale",
   "missing_snapshot",
   "hash_mismatch"
 ]);
-var clientReviewBatchStatus = z2.enum(["open", "waiting_internal", "pending", "completed", "expired", "cancelled"]);
-var clientReviewItemStatus = z2.enum(["pending", "approved", "changes_requested", "admin_overridden", "cancelled"]);
-var approvalRequestSchema = z2.object({
-  approverIds: z2.array(uuid2).min(1),
+var clientReviewBatchStatus = z3.enum(["open", "waiting_internal", "pending", "completed", "expired", "cancelled"]);
+var clientReviewItemStatus = z3.enum(["pending", "approved", "changes_requested", "admin_overridden", "cancelled"]);
+var approvalRequestSchema = z3.object({
+  approverIds: z3.array(uuid3).min(1),
   policy: approvalPolicy
 });
-var approvalDecisionSchema = z2.object({
-  decision: z2.enum(["approve", "reject"]),
-  override: z2.boolean().optional(),
-  reason: z2.string().max(2e3).optional()
+var approvalDecisionSchema = z3.object({
+  decision: z3.enum(["approve", "reject"]),
+  override: z3.boolean().optional(),
+  reason: z3.string().max(2e3).optional()
 }).refine((payload) => !(payload.decision === "reject" || payload.override === true) || Boolean(payload.reason?.trim()), {
   message: "reason is required when rejecting or using override."
 });
-var approvalCommentSchema = z2.object({
-  body: z2.string().max(2e3).optional(),
-  attachmentId: uuid2.optional()
+var approvalCommentSchema = z3.object({
+  body: z3.string().max(2e3).optional(),
+  attachmentId: uuid3.optional()
 }).refine((payload) => Boolean(payload.body?.trim() || payload.attachmentId), {
   message: "Comment payload must include body or attachmentId."
 });
-var approvalAttachmentInitSchema = z2.object({
-  contentId: uuid2,
-  batchId: uuid2.optional(),
-  audience: z2.enum(["internal", "client"]),
+var approvalAttachmentInitSchema = z3.object({
+  contentId: uuid3,
+  batchId: uuid3.optional(),
+  audience: z3.enum(["internal", "client"]),
   filename: nonEmptyString.max(255),
   contentType: attachmentContentType,
-  fileSize: z2.number().int().min(1)
+  fileSize: z3.number().int().min(1)
 });
-var approvalReactionSchema = z2.object({
+var approvalReactionSchema = z3.object({
   emoji: nonEmptyString.max(16)
 });
-var clientReviewerSchema = z2.object({
+var clientReviewerSchema = z3.object({
   name: nonEmptyString.max(255),
-  email: z2.string().email().max(320)
+  email: z3.string().email().max(320)
 });
-var clientReviewConfigSchema = z2.object({
-  reviewers: z2.array(clientReviewerSchema).min(1),
+var clientReviewConfigSchema = z3.object({
+  reviewers: z3.array(clientReviewerSchema).min(1),
   policy: approvalPolicy,
   expiresAt: nullableString,
   inviteNote: nullableString.refine((value) => value === void 0 || value === null || value.length <= 2e3, {
@@ -819,79 +1004,79 @@ var clientReviewConfigSchema = z2.object({
     message: "batchLabel must be 255 characters or fewer."
   })
 });
-var internalReviewConfigSchema = z2.object({
-  approverIds: z2.array(uuid2).min(1),
+var internalReviewConfigSchema = z3.object({
+  approverIds: z3.array(uuid3).min(1),
   policy: approvalPolicy
 });
-var clientReviewCreateSchema = z2.object({
-  contentIds: z2.array(uuid2).min(1),
+var clientReviewCreateSchema = z3.object({
+  contentIds: z3.array(uuid3).min(1),
   workflowMode,
   client: clientReviewConfigSchema,
   internal: internalReviewConfigSchema.optional()
 }).refine((payload) => payload.workflowMode !== "internal_client" || Boolean(payload.internal), {
   message: "internal is required when workflowMode is internal_client."
 });
-var clientReviewPostMutationSchema = z2.object({
-  contentId: uuid2
+var clientReviewPostMutationSchema = z3.object({
+  contentId: uuid3
 });
-var clientReviewOverrideSchema = z2.object({
-  contentId: uuid2,
+var clientReviewOverrideSchema = z3.object({
+  contentId: uuid3,
   reason: nonEmptyString.max(2e3)
 });
-var clientReviewParticipantUpdateSchema = z2.object({
-  participantId: uuid2,
-  email: z2.string().email().max(320),
-  name: z2.string().max(255).optional()
+var clientReviewParticipantUpdateSchema = z3.object({
+  participantId: uuid3,
+  email: z3.string().email().max(320),
+  name: z3.string().max(255).optional()
 });
-var clientReviewCommentSchema = z2.object({
-  contentId: uuid2,
-  body: z2.string().max(2e3).optional(),
-  attachmentId: uuid2.optional()
+var clientReviewCommentSchema = z3.object({
+  contentId: uuid3,
+  body: z3.string().max(2e3).optional(),
+  attachmentId: uuid3.optional()
 }).refine((payload) => Boolean(payload.body?.trim() || payload.attachmentId), {
   message: "Comment payload must include body or attachmentId."
 });
-var reviewLifecycleSchema = z2.object({
+var reviewLifecycleSchema = z3.object({
   phase: reviewLifecyclePhase,
   state: reviewLifecycleState,
   actor: reviewLifecycleActor,
   nextAction: reviewLifecycleNextAction,
-  blocksPublishing: z2.boolean(),
-  blockers: z2.array(
-    z2.object({
+  blocksPublishing: z3.boolean(),
+  blockers: z3.array(
+    z3.object({
       code: reviewLifecycleBlockerCode,
-      message: z2.string().optional(),
-      details: z2.record(z2.string(), z2.unknown()).optional()
+      message: z3.string().optional(),
+      details: z3.record(z3.string(), z3.unknown()).optional()
     }).strict()
   ),
-  progress: z2.object({
+  progress: z3.object({
     policy: approvalPolicy.nullable(),
-    requestedCount: z2.number().int().min(0),
-    approvedCount: z2.number().int().min(0),
-    changesRequestedCount: z2.number().int().min(0).optional()
+    requestedCount: z3.number().int().min(0),
+    approvedCount: z3.number().int().min(0),
+    changesRequestedCount: z3.number().int().min(0).optional()
   }).strict().nullable().optional(),
-  clientReview: z2.object({
-    batchId: uuid2.nullable(),
-    itemId: uuid2.nullable(),
+  clientReview: z3.object({
+    batchId: uuid3.nullable(),
+    itemId: uuid3.nullable(),
     batchStatus: clientReviewBatchStatus.nullable(),
     itemStatus: clientReviewItemStatus.nullable(),
-    isClientFacing: z2.boolean(),
+    isClientFacing: z3.boolean(),
     sharedVersionStatus: reviewLifecycleSharedVersionStatus,
-    hasSentLinkBefore: z2.boolean().optional(),
-    readyForClientSend: z2.boolean().optional()
+    hasSentLinkBefore: z3.boolean().optional(),
+    readyForClientSend: z3.boolean().optional()
   }).strict().nullable().optional(),
-  labels: z2.object({
-    phase: z2.string().optional(),
-    state: z2.string().optional(),
-    nextAction: z2.string().optional()
+  labels: z3.object({
+    phase: z3.string().optional(),
+    state: z3.string().optional(),
+    nextAction: z3.string().optional()
   }).strict().optional()
 }).strict();
-var reviewLifecycleResponseSchema = z2.object({
+var reviewLifecycleResponseSchema = z3.object({
   reviewLifecycle: reviewLifecycleSchema.nullable().optional()
 }).passthrough();
 
 // src/commands/client-reviews.ts
 function registerClientReviewCommands(program) {
-  addConnectionOptions(program.command("client-reviews:create")).description("Create a client review batch. Requires agency plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing the client review batch payload.").action(async (options, command) => {
+  addConnectionOptions(program.command("client-reviews:create")).description("Create a client review batch. Requires team plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing the client review batch payload.").action(async (options, command) => {
     const payload = clientReviewCreateSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -901,7 +1086,7 @@ function registerClientReviewCommands(program) {
     );
   });
   addConnectionOptions(program.command("client-reviews:open")).description(
-    "List open client review batches that have not had links sent. Requires agency plan and client review read capability."
+    "List open client review batches that have not had links sent. Requires team plan and client review read capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").option("--workflow-mode <mode>", "Workflow mode: client or internal_client.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -910,7 +1095,7 @@ function registerClientReviewCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("client-reviews:get")).description("Get one client review batch. Requires agency plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("client-reviews:get")).description("Get one client review batch. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
       await client.request(
@@ -919,7 +1104,7 @@ function registerClientReviewCommands(program) {
       )
     );
   });
-  addConnectionOptions(program.command("client-reviews:add-post")).description("Add content to an open client review batch. Requires agency plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing contentId.").action(async (options, command) => {
+  addConnectionOptions(program.command("client-reviews:add-post")).description("Add content to an open client review batch. Requires team plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing contentId.").action(async (options, command) => {
     const payload = clientReviewPostMutationSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -931,7 +1116,7 @@ function registerClientReviewCommands(program) {
     );
   });
   addConnectionOptions(program.command("client-reviews:remove-post")).description(
-    "Remove content from an open client review batch. Requires agency plan and client review send capability."
+    "Remove content from an open client review batch. Requires team plan and client review send capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing contentId.").action(async (options, command) => {
     const payload = clientReviewPostMutationSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
@@ -944,7 +1129,7 @@ function registerClientReviewCommands(program) {
     );
   });
   addConnectionOptions(program.command("client-reviews:send")).description(
-    "Send a client review batch. Requires agency plan and client review send capability; may notify reviewers."
+    "Send a client review batch. Requires team plan and client review send capability; may notify reviewers."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").option("--yes", "Confirm reviewer notifications.").action(async (options, command) => {
     if (!options.yes) {
       throw new CliError("client-reviews:send requires --yes because it may notify reviewers.", {
@@ -960,7 +1145,7 @@ function registerClientReviewCommands(program) {
     );
   });
   addConnectionOptions(program.command("client-reviews:resend")).description(
-    "Resend a client review batch. Requires agency plan and client review send capability; may notify reviewers."
+    "Resend a client review batch. Requires team plan and client review send capability; may notify reviewers."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").option("--yes", "Confirm reviewer notifications.").action(async (options, command) => {
     if (!options.yes) {
       throw new CliError("client-reviews:resend requires --yes because it may notify reviewers.", {
@@ -975,7 +1160,7 @@ function registerClientReviewCommands(program) {
       )
     );
   });
-  addConnectionOptions(program.command("client-reviews:cancel")).description("Cancel a client review batch. Requires agency plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("client-reviews:cancel")).description("Cancel a client review batch. Requires team plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
       await client.request(
@@ -984,7 +1169,7 @@ function registerClientReviewCommands(program) {
       )
     );
   });
-  addConnectionOptions(program.command("client-reviews:override")).description("Override a client review batch item. Requires agency plan and content review override capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing contentId and reason.").action(async (options, command) => {
+  addConnectionOptions(program.command("client-reviews:override")).description("Override a client review batch item. Requires team plan and content review override capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing contentId and reason.").action(async (options, command) => {
     const payload = clientReviewOverrideSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -995,7 +1180,7 @@ function registerClientReviewCommands(program) {
       )
     );
   });
-  addConnectionOptions(program.command("client-reviews:update-participant")).description("Update a client review participant. Requires agency plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing participantId and email.").action(async (options, command) => {
+  addConnectionOptions(program.command("client-reviews:update-participant")).description("Update a client review participant. Requires team plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing participantId and email.").action(async (options, command) => {
     const payload = clientReviewParticipantUpdateSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -1007,7 +1192,7 @@ function registerClientReviewCommands(program) {
     );
   });
   addConnectionOptions(program.command("client-reviews:comment")).description(
-    "Add an internal client-review thread comment. Requires agency plan and client review comment capability."
+    "Add an internal client-review thread comment. Requires team plan and client review comment capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").requiredOption("--json <file>", "JSON file containing contentId and body or attachmentId.").action(async (options, command) => {
     const payload = clientReviewCommentSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
@@ -1025,9 +1210,9 @@ function registerClientReviewCommands(program) {
 import { randomUUID } from "crypto";
 
 // src/content-schema.ts
-import { z as z3 } from "zod";
-var uuid3 = z3.string().uuid();
-var isoWithTimezone = z3.string().refine(
+import { z as z4 } from "zod";
+var uuid4 = z4.string().uuid();
+var isoWithTimezone = z4.string().refine(
   (value) => {
     const date = new Date(value);
     return !Number.isNaN(date.getTime()) && (value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value));
@@ -1036,42 +1221,42 @@ var isoWithTimezone = z3.string().refine(
     message: "scheduledAt must be an ISO8601 date string with explicit timezone, e.g. 2026-05-01T10:00:00Z."
   }
 );
-var captionOverridesSchema = z3.object({
-  x: z3.string().max(25e3).optional(),
-  linkedin: z3.string().max(25e3).optional(),
-  youtube: z3.string().max(25e3).optional(),
-  instagram: z3.string().max(25e3).optional(),
-  facebook: z3.string().max(25e3).optional(),
-  threads: z3.string().max(25e3).optional(),
-  tiktok: z3.string().max(25e3).optional(),
-  pinterest: z3.string().max(25e3).optional()
+var captionOverridesSchema = z4.object({
+  x: z4.string().max(25e3).optional(),
+  linkedin: z4.string().max(25e3).optional(),
+  youtube: z4.string().max(25e3).optional(),
+  instagram: z4.string().max(25e3).optional(),
+  facebook: z4.string().max(25e3).optional(),
+  threads: z4.string().max(25e3).optional(),
+  tiktok: z4.string().max(25e3).optional(),
+  pinterest: z4.string().max(25e3).optional()
 }).strict();
-var captionsSchema = z3.object({
-  canonical: z3.string().max(25e3).nullable().optional(),
+var captionsSchema = z4.object({
+  canonical: z4.string().max(25e3).nullable().optional(),
   overrides: captionOverridesSchema.optional()
 }).strict();
-var contentMediaCoverSchema = z3.object({
-  coverMediaId: uuid3.optional(),
-  thumbOffsetMs: z3.number().int().min(0).optional()
+var contentMediaCoverSchema = z4.object({
+  coverMediaId: uuid4.optional(),
+  thumbOffsetMs: z4.number().int().min(0).optional()
 }).strict().nullable();
-var contentMediaSchema = z3.array(
-  z3.object({
-    mediaId: uuid3,
-    order: z3.number().int().min(0).optional(),
-    crops: z3.record(z3.string(), z3.unknown()).optional(),
-    userTags: z3.array(
-      z3.object({
-        username: z3.string().min(1),
-        x: z3.number().min(0).max(1),
-        y: z3.number().min(0).max(1)
+var contentMediaSchema = z4.array(
+  z4.object({
+    mediaId: uuid4,
+    order: z4.number().int().min(0).optional(),
+    crops: z4.record(z4.string(), z4.unknown()).optional(),
+    userTags: z4.array(
+      z4.object({
+        username: z4.string().min(1),
+        x: z4.number().min(0).max(1),
+        y: z4.number().min(0).max(1)
       }).strict()
     ).optional(),
-    productTags: z3.array(
-      z3.object({
-        productId: z3.string().min(1),
-        productName: z3.string().max(500).optional(),
-        x: z3.number().min(0).max(1).optional(),
-        y: z3.number().min(0).max(1).optional()
+    productTags: z4.array(
+      z4.object({
+        productId: z4.string().min(1),
+        productName: z4.string().max(500).optional(),
+        x: z4.number().min(0).max(1).optional(),
+        y: z4.number().min(0).max(1).optional()
       }).strict()
     ).optional(),
     cover: contentMediaCoverSchema.optional()
@@ -1115,37 +1300,37 @@ var threadsReplyControlValues = [
   "parent_post_author_only",
   "followers_only"
 ];
-var settingsSchema = z3.object({
-  collaborators: z3.array(z3.string()).optional(),
-  locationId: z3.string().optional(),
-  facebookLinkUrl: z3.string().optional(),
-  facebookCtaType: z3.enum(facebookPagePostCtaTypes).optional(),
-  facebookLocationId: z3.string().optional(),
-  xCommunityUrl: z3.string().optional(),
-  topicTag: z3.string().optional(),
-  linkAttachment: z3.string().optional(),
-  isGhostPost: z3.boolean().optional(),
-  replyControl: z3.enum(threadsReplyControlValues).optional(),
-  privacy_level: z3.string().optional(),
-  disable_comment: z3.boolean().optional(),
-  disable_duet: z3.boolean().optional(),
-  disable_stitch: z3.boolean().optional(),
-  brand_content_toggle: z3.boolean().optional(),
-  brand_organic_toggle: z3.boolean().optional(),
-  is_aigc: z3.boolean().optional(),
-  tiktok_post_to_drafts: z3.boolean().optional(),
-  photo_cover_index: z3.number().optional(),
-  auto_add_music: z3.boolean().optional(),
-  privacyStatus: z3.enum(["public", "unlisted", "private"]).optional(),
-  categoryId: z3.string().optional(),
-  tags: z3.array(z3.string()).optional(),
-  madeForKids: z3.boolean().optional(),
-  notifySubscribers: z3.boolean().optional(),
-  embeddable: z3.boolean().optional(),
-  license: z3.enum(["youtube", "creativeCommon"]).optional(),
-  boardId: z3.string().optional(),
-  link: z3.string().optional(),
-  altText: z3.string().optional()
+var settingsSchema = z4.object({
+  collaborators: z4.array(z4.string()).optional(),
+  locationId: z4.string().optional(),
+  facebookLinkUrl: z4.string().optional(),
+  facebookCtaType: z4.enum(facebookPagePostCtaTypes).optional(),
+  facebookLocationId: z4.string().optional(),
+  xCommunityUrl: z4.string().optional(),
+  topicTag: z4.string().optional(),
+  linkAttachment: z4.string().optional(),
+  isGhostPost: z4.boolean().optional(),
+  replyControl: z4.enum(threadsReplyControlValues).optional(),
+  privacy_level: z4.string().optional(),
+  disable_comment: z4.boolean().optional(),
+  disable_duet: z4.boolean().optional(),
+  disable_stitch: z4.boolean().optional(),
+  brand_content_toggle: z4.boolean().optional(),
+  brand_organic_toggle: z4.boolean().optional(),
+  is_aigc: z4.boolean().optional(),
+  tiktok_post_to_drafts: z4.boolean().optional(),
+  photo_cover_index: z4.number().optional(),
+  auto_add_music: z4.boolean().optional(),
+  privacyStatus: z4.enum(["public", "unlisted", "private"]).optional(),
+  categoryId: z4.string().optional(),
+  tags: z4.array(z4.string()).optional(),
+  madeForKids: z4.boolean().optional(),
+  notifySubscribers: z4.boolean().optional(),
+  embeddable: z4.boolean().optional(),
+  license: z4.enum(["youtube", "creativeCommon"]).optional(),
+  boardId: z4.string().optional(),
+  link: z4.string().optional(),
+  altText: z4.string().optional()
 }).strict().superRefine((settings, context) => {
   for (const key of unsupportedSettingsKeys) {
     if (Object.prototype.hasOwnProperty.call(settings, key)) {
@@ -1157,28 +1342,30 @@ var settingsSchema = z3.object({
     }
   }
 }).optional();
-var createContentBaseSchema = z3.object({
-  intent: z3.enum(["draft", "schedule", "publish_now"]).default("draft"),
-  integrationId: uuid3,
-  internalTitle: z3.string().max(500).nullable().optional(),
-  publishTitle: z3.string().max(500).nullable().optional(),
-  notes: z3.string().max(1e5).optional(),
+var createContentBaseSchema = z4.object({
+  intent: z4.enum(["draft", "schedule", "publish_now"]).default("draft"),
+  integrationId: uuid4,
+  internalTitle: z4.string().max(500).nullable().optional(),
+  publishTitle: z4.string().max(500).nullable().optional(),
+  notes: z4.string().max(1e5).optional(),
   captions: captionsSchema.optional(),
   contentMedia: contentMediaSchema.optional(),
   scheduledAt: isoWithTimezone.optional(),
   settings: settingsSchema,
-  postType: z3.enum(["post", "reel", "story", "thread"]).optional(),
-  firstComment: z3.string().optional(),
-  shareToFeed: z3.boolean().optional(),
-  pillarIds: z3.array(uuid3).optional(),
-  formatIds: z3.array(uuid3).optional(),
-  labelIds: z3.array(uuid3).optional(),
-  campaignId: uuid3.nullable().optional(),
-  campaignPhaseId: uuid3.nullable().optional(),
-  priority: z3.enum(["urgent", "high", "medium", "low"]).optional(),
-  assigneeIds: z3.array(uuid3).optional(),
-  threadMessages: z3.array(
-    z3.object({
+  postType: z4.enum(["post", "reel", "story", "thread"]).optional(),
+  firstComment: z4.string().optional(),
+  shareToFeed: z4.boolean().optional(),
+  pillarIds: z4.array(uuid4).optional(),
+  formatIds: z4.array(uuid4).optional(),
+  labelIds: z4.array(uuid4).optional(),
+  // Root-post metadata. The API accepts these on content payloads and stores
+  // them on the canonical post record, not the channel edition row.
+  campaignId: uuid4.nullable().optional(),
+  campaignPhaseId: uuid4.nullable().optional(),
+  priority: z4.enum(["urgent", "high", "medium", "low"]).optional(),
+  assigneeIds: z4.array(uuid4).optional(),
+  threadMessages: z4.array(
+    z4.object({
       captions: captionsSchema,
       contentMedia: contentMediaSchema.optional()
     }).strict()
@@ -1210,17 +1397,14 @@ var createContentSchema = createContentBaseSchema.superRefine((payload, ctx) =>
 var updateContentSchema = createContentBaseSchema.omit({ intent: true }).partial().refine((payload) => Object.keys(payload).length > 0, {
   message: "Update payload must include at least one field."
 });
-var scheduleContentSchema = z3.object({
+var scheduleContentSchema = z4.object({
   scheduledAt: isoWithTimezone
 });
-var workflowStatusSchema = z3.object({
-  workflowStatus: z3.enum(["idea", "drafting"])
-});
-var updateContentNotesSchema = z3.object({
-  notes: z3.string().max(1e5)
+var updateContentNotesSchema = z4.object({
+  notes: z4.string().max(1e5)
 });
-var updatePublishedCaptionSchema = z3.object({
-  message: z3.string().max(25e3)
+var updatePublishedCaptionSchema = z4.object({
+  message: z4.string().max(25e3)
 }).strict();
 
 // src/commands/content.ts
@@ -1321,15 +1505,6 @@ function registerContentCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("content:workflow")).description("Update a content item workflow status. Allowed statuses: idea, drafting (In Progress).").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").requiredOption("--status <status>", "Workflow status: idea or drafting (In Progress).").action(async (options, command) => {
-    const payload = workflowStatusSchema.parse({ workflowStatus: options.status });
-    const client = createApiClient(resolveConfig(command));
-    writeRawJson(
-      await client.request("PATCH", `/v1/workspaces/${options.workspace}/content/${options.id}/workflow-status`, {
-        body: payload
-      })
-    );
-  });
   addConnectionOptions(program.command("content:get")).description("Get one content item.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/content/${options.id}`));
@@ -1376,11 +1551,11 @@ function registerContentCommands(program) {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/content/failed-count`));
   });
-  addConnectionOptions(program.command("content:pending-approval-count")).description("Get the pending approval count for a workspace. Requires agency plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:pending-approval-count")).description("Get the pending approval count for a workspace. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/content/pending-approval-count`));
   });
-  addConnectionOptions(program.command("content:approval-history")).description("List approval history for a workspace. Requires agency plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--limit <number>", "Page size.").option("--cursor <cursor>", "Pagination cursor.").option("--search <text>", "Search approval history.").option("--workflow-path <path>", "Workflow path: all, internal, client, or internal_client.").option("--outcome <outcome>", "Outcome filter.").option("--platform <platform>", "Platform filter.").option("--reviewer <text>", "Reviewer filter.").option("--date-from <iso>", "ISO8601 start date.").option("--date-to <iso>", "ISO8601 end date.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:approval-history")).description("List approval history for a workspace. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--limit <number>", "Page size.").option("--cursor <cursor>", "Pagination cursor.").option("--search <text>", "Search approval history.").option("--workflow-path <path>", "Workflow path: all, internal, client, or internal_client.").option("--outcome <outcome>", "Outcome filter.").option("--platform <platform>", "Platform filter.").option("--reviewer <text>", "Reviewer filter.").option("--date-from <iso>", "ISO8601 start date.").option("--date-to <iso>", "ISO8601 end date.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
       await client.request("GET", `/v1/workspaces/${options.workspace}/content/approval-history`, {
@@ -1398,7 +1573,7 @@ function registerContentCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("content:approval-history:client-batch")).description("Get client batch approval history detail. Requires agency plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:approval-history:client-batch")).description("Get client batch approval history detail. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--batch <batchId>", "Client review batch ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
       await client.request(
@@ -1407,7 +1582,7 @@ function registerContentCommands(program) {
       )
     );
   });
-  addConnectionOptions(program.command("content:approval-history:internal")).description("Get internal approval history detail. Requires agency plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--record <recordId>", "Approval record ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:approval-history:internal")).description("Get internal approval history detail. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--record <recordId>", "Approval record ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
       await client.request(
@@ -1417,7 +1592,7 @@ function registerContentCommands(program) {
     );
   });
   addConnectionOptions(program.command("content:comment-attachments:init")).description(
-    "Initialize an approval comment attachment upload. Requires agency plan and content review comment capability."
+    "Initialize an approval comment attachment upload. Requires team plan and content review comment capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing the attachment upload payload.").action(async (options, command) => {
     const payload = approvalAttachmentInitSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
@@ -1428,7 +1603,7 @@ function registerContentCommands(program) {
     );
   });
   addConnectionOptions(program.command("content:comment-attachments:complete")).description(
-    "Complete an approval comment attachment upload. Requires agency plan and content review comment capability."
+    "Complete an approval comment attachment upload. Requires team plan and content review comment capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--attachment <attachmentId>", "Attachment ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -1439,7 +1614,7 @@ function registerContentCommands(program) {
     );
   });
   addConnectionOptions(program.command("content:comment-attachments:abort")).description(
-    "Abort an approval comment attachment upload. Requires agency plan and content review comment capability."
+    "Abort an approval comment attachment upload. Requires team plan and content review comment capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--attachment <attachmentId>", "Attachment ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -1449,7 +1624,7 @@ function registerContentCommands(program) {
       )
     );
   });
-  addConnectionOptions(program.command("content:activity:react")).description("Add a reaction to an approval activity. Requires agency plan and content review comment capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--activity <activityId>", "Activity ID.").requiredOption("--json <file>", "JSON file containing emoji.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:activity:react")).description("Add a reaction to an approval activity. Requires team plan and content review comment capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--activity <activityId>", "Activity ID.").requiredOption("--json <file>", "JSON file containing emoji.").action(async (options, command) => {
     const payload = approvalReactionSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -1463,7 +1638,7 @@ function registerContentCommands(program) {
     );
   });
   addConnectionOptions(program.command("content:activity:unreact")).description(
-    "Remove a reaction from an approval activity. Requires agency plan and content review comment capability."
+    "Remove a reaction from an approval activity. Requires team plan and content review comment capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--activity <activityId>", "Activity ID.").requiredOption("--emoji <emoji>", "Reaction emoji to remove.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -1474,7 +1649,7 @@ function registerContentCommands(program) {
     );
   });
   addConnectionOptions(program.command("content:request-approval")).description(
-    "Request internal approval for a content item. Requires agency plan and content review request capability; may notify approvers."
+    "Request internal approval for a content item. Requires team plan and content review request capability; may notify approvers."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").requiredOption("--json <file>", "JSON file containing approverIds and policy.").option("--yes", "Confirm approver notifications.").action(async (options, command) => {
     if (!options.yes) {
       throw new CliError("content:request-approval requires --yes because it may notify approvers.", {
@@ -1489,7 +1664,7 @@ function registerContentCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("content:decision")).description("Submit an internal approval decision. Requires agency plan and content review decision capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").requiredOption("--json <file>", "JSON file containing decision, optional override, and reason.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:decision")).description("Submit an internal approval decision. Requires team plan and content review decision capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").requiredOption("--json <file>", "JSON file containing decision, optional override, and reason.").action(async (options, command) => {
     const payload = approvalDecisionSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -1498,12 +1673,12 @@ function registerContentCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("content:withdraw")).description("Withdraw an internal approval request. Requires agency plan and content review withdraw capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:withdraw")).description("Withdraw an internal approval request. Requires team plan and content review withdraw capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("POST", `/v1/workspaces/${options.workspace}/content/${options.id}/withdraw`));
   });
   addConnectionOptions(program.command("content:resubmit")).description(
-    "Resubmit rejected content for approval. Requires agency plan and content review request capability; may notify approvers."
+    "Resubmit rejected content for approval. Requires team plan and content review request capability; may notify approvers."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").requiredOption("--json <file>", "JSON file containing approverIds and policy.").option("--yes", "Confirm approver notifications.").action(async (options, command) => {
     if (!options.yes) {
       throw new CliError("content:resubmit requires --yes because it may notify approvers.", {
@@ -1518,12 +1693,12 @@ function registerContentCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("content:history")).description("Get approval activity history for one content item. Requires agency plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:history")).description("Get approval activity history for one content item. Requires team plan.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/content/${options.id}/history`));
   });
   addConnectionOptions(program.command("content:comment")).description(
-    "Add an internal approval comment to one content item. Requires agency plan and content review comment capability."
+    "Add an internal approval comment to one content item. Requires team plan and content review comment capability."
   ).requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").requiredOption("--json <file>", "JSON file containing body or attachmentId.").action(async (options, command) => {
     const payload = approvalCommentSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
@@ -1533,7 +1708,7 @@ function registerContentCommands(program) {
       })
     );
   });
-  addConnectionOptions(program.command("content:reopen-client-review")).description("Reopen client review for one content item. Requires agency plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
+  addConnectionOptions(program.command("content:reopen-client-review")).description("Reopen client review for one content item. Requires team plan and client review send capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <contentId>", "Content ID.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
       await client.request("POST", `/v1/workspaces/${options.workspace}/content/${options.id}/reopen-client-review`)
@@ -1547,24 +1722,24 @@ function registerContentCommands(program) {
 }
 
 // src/grid-planner-schema.ts
-import { z as z4 } from "zod";
-var uuidV4 = z4.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, "Expected a UUIDv4 string.");
-var placeholderSettingsSchema = z4.object({
-  title: z4.string().trim().min(1).max(40),
-  color: z4.string().regex(/^#[0-9a-fA-F]{6}$/)
+import { z as z5 } from "zod";
+var uuidV4 = z5.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, "Expected a UUIDv4 string.");
+var placeholderSettingsSchema = z5.object({
+  title: z5.string().trim().min(1).max(40),
+  color: z5.string().regex(/^#[0-9a-fA-F]{6}$/)
 }).strict();
-var settingsSchema2 = z4.object({
-  aspectRatio: z4.number().min(0.1).max(10).nullable().optional(),
+var settingsSchema2 = z5.object({
+  aspectRatio: z5.number().min(0.1).max(10).nullable().optional(),
   placeholder: placeholderSettingsSchema.optional()
 }).strict();
-var gridPlannerCreateSchema = z4.object({
+var gridPlannerCreateSchema = z5.object({
   integrationId: uuidV4,
-  kind: z4.enum(["visual_only", "linked_post", "placeholder"]),
-  mediaIds: z4.array(uuidV4).min(1).optional(),
+  kind: z5.enum(["visual_only", "linked_post", "placeholder"]),
+  mediaIds: z5.array(uuidV4).min(1).optional(),
   linkedContentId: uuidV4.optional(),
   coverMediaId: uuidV4.nullable().optional(),
-  note: z4.string().optional(),
-  position: z4.number().int().min(0).optional(),
+  note: z5.string().optional(),
+  position: z5.number().int().min(0).optional(),
   settings: settingsSchema2.optional()
 }).strict().superRefine((payload, context) => {
   if (payload.kind === "visual_only" && !payload.mediaIds) {
@@ -1626,18 +1801,18 @@ var gridPlannerCreateSchema = z4.object({
     });
   }
 });
-var gridPlannerUpdateSchema = z4.object({
+var gridPlannerUpdateSchema = z5.object({
   integrationId: uuidV4,
-  note: z4.string().nullable().optional(),
+  note: z5.string().nullable().optional(),
   settings: settingsSchema2.optional()
 }).strict();
-var gridPlannerReorderSchema = z4.object({
+var gridPlannerReorderSchema = z5.object({
   integrationId: uuidV4,
-  itemIds: z4.array(uuidV4).min(1).optional(),
-  items: z4.array(
-    z4.object({
+  itemIds: z5.array(uuidV4).min(1).optional(),
+  items: z5.array(
+    z5.object({
       itemId: uuidV4,
-      position: z4.number().int().min(0)
+      position: z5.number().int().min(0)
     }).strict()
   ).min(1).optional()
 }).strict().refine((payload) => Boolean(payload.itemIds) !== Boolean(payload.items), {
@@ -1656,18 +1831,18 @@ var gridPlannerReorderSchema = z4.object({
     message: "items must contain unique positions."
   }
 );
-var gridPlannerReplaceMediaSchema = z4.object({
+var gridPlannerReplaceMediaSchema = z5.object({
   integrationId: uuidV4,
-  mediaIds: z4.array(uuidV4).min(1).max(10)
+  mediaIds: z5.array(uuidV4).min(1).max(10)
 }).strict().refine((payload) => new Set(payload.mediaIds).size === payload.mediaIds.length, {
   path: ["mediaIds"],
   message: "mediaIds must contain unique UUIDs."
 });
-var gridPlannerSetCoverSchema = z4.object({
+var gridPlannerSetCoverSchema = z5.object({
   integrationId: uuidV4,
   mediaId: uuidV4
 }).strict();
-var gridPlannerPromoteSchema = z4.object({
+var gridPlannerPromoteSchema = z5.object({
   integrationId: uuidV4
 }).strict();
 
@@ -1771,10 +1946,10 @@ function registerGridPlannerCommands(program) {
 }
 
 // src/commands/hashtags.ts
-import { z as z5 } from "zod";
-var hashtagGroupSchema = z5.object({
-  name: z5.string().trim().min(1).max(100),
-  content: z5.string().trim().min(1)
+import { z as z6 } from "zod";
+var hashtagGroupSchema = z6.object({
+  name: z6.string().trim().min(1).max(100),
+  content: z6.string().trim().min(1)
 });
 function registerHashtagCommands(program) {
   addConnectionOptions(program.command("hashtags:list")).description("List saved hashtag groups for a workspace.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
@@ -1806,31 +1981,49 @@ function registerHashtagCommands(program) {
 }
 
 // src/inbox-schema.ts
-import { z as z6 } from "zod";
-var uuid4 = z6.string().uuid();
-var inboxAttachmentSchema = z6.object({
-  type: z6.enum(["image", "video", "audio", "file"]),
-  url: z6.url()
+import { z as z7 } from "zod";
+var uuid5 = z7.string().uuid();
+var inboxAttachmentSchema = z7.object({
+  type: z7.enum(["image", "video", "audio", "file"]),
+  url: z7.url()
 });
-var inboxReplySchema = z6.object({
-  content: z6.string().max(2e3).optional(),
-  parentMessageId: uuid4.optional(),
+var inboxReplySchema = z7.object({
+  content: z7.string().max(2e3).optional(),
+  parentMessageId: uuid5.optional(),
   attachment: inboxAttachmentSchema.optional()
 }).refine((payload) => Boolean(payload.content?.trim() || payload.attachment), {
   message: "Reply payload must include content or attachment."
 });
-var inboxNoteSchema = z6.object({
-  content: z6.string().min(1).max(5e3)
+var inboxNoteSchema = z7.object({
+  content: z7.string().min(1).max(5e3)
 });
-var inboxModerateSchema = z6.object({
-  action: z6.enum(["hide", "unhide", "delete"])
+var inboxModerateSchema = z7.object({
+  action: z7.enum(["hide", "unhide", "delete"])
 });
-var inboxMarkAllReadSchema = z6.object({
-  platform: z6.enum(["instagram", "facebook", "threads"]).optional(),
-  status: z6.enum(["open", "archived", "all"]).optional(),
-  integrationId: z6.string().min(1).optional(),
-  messageType: z6.enum(["comment", "dm", "review", "mention"]).optional()
+var inboxMarkAllReadSchema = z7.object({
+  platform: z7.enum(["instagram", "facebook", "threads"]).optional(),
+  status: z7.enum(["open", "archived", "all"]).optional(),
+  integrationId: z7.string().min(1).optional(),
+  messageType: z7.enum(["comment", "dm", "review", "mention"]).optional()
 });
+var inboxResolveSchema = z7.object({
+  reason: z7.enum(["manual", "reply_sent", "moderated", "handled_natively", "handled_offline", "no_response_needed"]).optional(),
+  note: z7.string().max(1e3).optional()
+}).strict();
+var inboxResolveAllSchema = z7.object({
+  platform: z7.enum(["instagram", "facebook", "threads"]).optional(),
+  status: z7.enum(["open", "archived", "all"]).optional(),
+  integrationId: uuid5.optional(),
+  messageType: z7.enum(["comment", "dm", "review", "mention"]).optional(),
+  search: z7.string().max(200).optional(),
+  read: z7.enum(["read", "unread", "all"]).optional(),
+  resolution: z7.enum(["resolved", "unresolved", "all"]).optional(),
+  page: z7.number().int().min(1).optional(),
+  limit: z7.number().int().min(1).max(50).optional(),
+  threadIds: z7.array(uuid5).max(50).optional(),
+  reason: z7.enum(["manual", "reply_sent", "moderated", "handled_natively", "handled_offline", "no_response_needed"]).optional(),
+  note: z7.string().max(1e3).optional()
+}).strict();
 
 // src/commands/inbox.ts
 function registerInboxCommands(program) {
@@ -1948,6 +2141,50 @@ function registerInboxCommands(program) {
       await client.request("DELETE", `/v1/workspaces/${options.workspace}/inbox/messages/${options.message}/failed`)
     );
   });
+  addConnectionOptions(program.command("inbox:resolve")).description("Resolve an inbox thread. Requires inbox resolve capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--thread <threadId>", "Inbox thread ID.").option("--json <file>", "JSON file with optional resolution reason and note.").action(async (options, command) => {
+    const payload = inboxResolveSchema.parse(options.json ? await readJsonFile(options.json) : {});
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/inbox/threads/${options.thread}/resolve`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("inbox:reopen")).description("Reopen a resolved inbox thread. Requires inbox resolve capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--thread <threadId>", "Inbox thread ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("DELETE", `/v1/workspaces/${options.workspace}/inbox/threads/${options.thread}/resolve`)
+    );
+  });
+  addConnectionOptions(program.command("inbox:resolve-all")).description("Resolve matching inbox threads from a JSON filter payload. Requires inbox resolve capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing resolve-all filters.").option("--yes", "Confirm resolving matching threads.").action(async (options, command) => {
+    if (!options.yes) {
+      throw new CliError("inbox:resolve-all requires --yes because it can resolve many customer threads at once.", {
+        code: "INVALID_OPTIONS"
+      });
+    }
+    const payload = inboxResolveAllSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/inbox/threads/resolve-all`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("inbox:resolve-message")).description("Resolve an inbox message. Requires inbox resolve capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--message <messageId>", "Inbox message ID.").option("--json <file>", "JSON file with optional resolution reason and note.").action(async (options, command) => {
+    const payload = inboxResolveSchema.parse(options.json ? await readJsonFile(options.json) : {});
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/inbox/messages/${options.message}/resolve`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("inbox:reopen-message")).description("Reopen a resolved inbox message. Requires inbox resolve capability.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--message <messageId>", "Inbox message ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("DELETE", `/v1/workspaces/${options.workspace}/inbox/messages/${options.message}/resolve`)
+    );
+  });
 }
 
 // src/commands/integrations.ts
@@ -1981,51 +2218,67 @@ function registerIntegrationCommands(program) {
 }
 
 // src/media-schema.ts
-import { z as z7 } from "zod";
-var uuid5 = z7.string().uuid();
-var hexColor = z7.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, "Color must be a hex color.");
-var mediaUpdateSchema = z7.object({
-  filename: z7.string().min(1).max(255).optional(),
-  altText: z7.string().max(500).optional(),
-  isFavorite: z7.boolean().optional(),
-  folderId: uuid5.nullable().optional()
+import { z as z8 } from "zod";
+var uuid6 = z8.string().uuid();
+var hexColor2 = z8.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, "Color must be a hex color.");
+var mediaUpdateSchema = z8.object({
+  filename: z8.string().min(1).max(255).optional(),
+  altText: z8.string().max(500).optional(),
+  isFavorite: z8.boolean().optional(),
+  folderId: uuid6.nullable().optional()
 }).refine((payload) => Object.keys(payload).length > 0, {
   message: "Media update payload must include at least one field."
 });
-var createMediaFolderSchema = z7.object({
-  name: z7.string().min(1).max(255),
-  parentId: uuid5.optional()
+var createMediaFolderSchema = z8.object({
+  name: z8.string().min(1).max(255),
+  parentId: uuid6.optional()
 });
-var updateMediaFolderSchema = z7.object({
-  name: z7.string().min(1).max(255)
+var updateMediaFolderSchema = z8.object({
+  name: z8.string().min(1).max(255)
 });
-var moveMediaFolderSchema = z7.object({
-  parentId: uuid5.nullable().optional()
+var moveMediaFolderSchema = z8.object({
+  parentId: uuid6.nullable().optional()
 }).refine((payload) => Object.prototype.hasOwnProperty.call(payload, "parentId"), {
   message: "Folder move payload must include parentId. Use null to move to root."
 });
-var createMediaLabelSchema = z7.object({
-  name: z7.string().min(1).max(50),
-  color: hexColor.optional()
+var createMediaLabelSchema = z8.object({
+  name: z8.string().min(1).max(50),
+  color: hexColor2.optional()
 });
-var updateMediaLabelSchema = z7.object({
-  name: z7.string().min(1).max(50).optional(),
-  color: hexColor.optional()
+var updateMediaLabelSchema = z8.object({
+  name: z8.string().min(1).max(50).optional(),
+  color: hexColor2.optional()
 }).refine((payload) => Object.keys(payload).length > 0, {
   message: "Media label update payload must include at least one field."
 });
-var mediaIdsSchema = z7.object({
-  mediaIds: z7.array(uuid5).min(1).max(100)
+var mediaIdsSchema = z8.object({
+  mediaIds: z8.array(uuid6).min(1).max(100)
 });
 var mediaBulkMoveSchema = mediaIdsSchema.extend({
-  folderId: uuid5.nullable().optional()
+  folderId: uuid6.nullable().optional()
 });
-var mediaLabelIdsSchema = z7.object({
-  labelIds: z7.array(uuid5).min(1).max(50)
+var mediaLabelIdsSchema = z8.object({
+  labelIds: z8.array(uuid6).min(1).max(50)
 });
 var mediaBulkLabelSchema = mediaIdsSchema.extend({
-  labelIds: z7.array(uuid5).min(1).max(50)
+  labelIds: z8.array(uuid6).min(1).max(50)
 });
+var mergeLabelsSchema = z8.object({ targetLabelId: uuid6 }).strict();
+var createLabelGroupSchema = z8.object({
+  name: z8.string().min(1).max(100),
+  color: hexColor2.nullable().optional(),
+  sortOrder: z8.number().int().optional()
+}).strict();
+var updateLabelGroupSchema = z8.object({
+  name: z8.string().max(100).optional(),
+  color: hexColor2.nullable().optional(),
+  sortOrder: z8.number().int().optional()
+}).strict().refine((payload) => Object.keys(payload).length > 0, {
+  message: "Label group update payload must include at least one field."
+});
+var deleteLabelGroupSchema = z8.object({ mode: z8.enum(["archive-labels", "ungroup-labels"]) }).strict();
+var reorderLabelGroupsSchema = z8.object({ groupIds: z8.array(uuid6) }).strict();
+var moveLabelsToGroupSchema = z8.object({ labelIds: z8.array(uuid6).min(1).max(100) }).strict();
 
 // src/commands/media.ts
 function registerMediaCommands(program) {
@@ -2068,6 +2321,14 @@ function registerMediaCommands(program) {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/media/${options.id}`));
   });
+  addConnectionOptions(program.command("media:usage-history")).description("Get usage history for one media item.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <mediaId>", "Media ID.").option("--limit <number>", "Page size.").option("--cursor <cursor>", "Pagination cursor.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/media/${options.id}/usage-history`, {
+        query: { limit: options.limit, cursor: options.cursor }
+      })
+    );
+  });
   addConnectionOptions(program.command("media:update")).description("Update one media item from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <mediaId>", "Media ID.").requiredOption("--json <file>", "JSON file containing fields to update.").action(async (options, command) => {
     const payload = mediaUpdateSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
@@ -2093,6 +2354,19 @@ function registerMediaCommands(program) {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(await client.request("DELETE", `/v1/workspaces/${options.workspace}/media/${options.id}`));
   });
+  addConnectionOptions(program.command("media:restore")).description("Restore one media item from the Bin.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <mediaId>", "Media ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("POST", `/v1/workspaces/${options.workspace}/media/${options.id}/restore`));
+  });
+  addConnectionOptions(program.command("media:delete-permanent")).description("Permanently delete one media item from the Bin. This cannot be undone.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <mediaId>", "Media ID.").option("--yes", "Confirm permanent deletion.").action(async (options, command) => {
+    if (!options.yes) {
+      throw new CliError("media:delete-permanent requires --yes because it permanently deletes media.", {
+        code: "INVALID_OPTIONS"
+      });
+    }
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("DELETE", `/v1/workspaces/${options.workspace}/media/${options.id}/permanent`));
+  });
   addConnectionOptions(program.command("media:folders:list")).description("List media folders.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--parent-id <id>", "Parent folder ID, or root for top-level folders.").action(async (options, command) => {
     const client = createApiClient(resolveConfig(command));
     writeRawJson(
@@ -2188,6 +2462,97 @@ function registerMediaCommands(program) {
       })
     );
   });
+  addConnectionOptions(program.command("media:labels:usage")).description("Get workspace label usage counts for media.").requiredOption("-w, --workspace <id>", "Workspace ID.").option("--label-ids <ids>", "Comma-separated label IDs to scope the counts.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("GET", `/v1/workspaces/${options.workspace}/media/labels/usage`, {
+        query: { labelIds: options.labelIds }
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:labels:health")).description("Get the workspace label health summary for media.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/media/labels/health`));
+  });
+  addConnectionOptions(program.command("media:labels:archive")).description("Archive one media label.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <labelId>", "Media label ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/labels/${options.id}/archive`)
+    );
+  });
+  addConnectionOptions(program.command("media:labels:restore")).description("Restore one archived media label.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <labelId>", "Media label ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/labels/${options.id}/restore`)
+    );
+  });
+  addConnectionOptions(program.command("media:labels:merge")).description("Merge one media label into another from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <labelId>", "Source media label ID.").requiredOption("--json <file>", "JSON file containing targetLabelId.").action(async (options, command) => {
+    const payload = mergeLabelsSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/labels/${options.id}/merge`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:label-groups:list")).description("List media label groups.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/media/label-groups`));
+  });
+  addConnectionOptions(program.command("media:label-groups:create")).description("Create a media label group from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing the label group payload.").action(async (options, command) => {
+    const payload = createLabelGroupSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/label-groups`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:label-groups:update")).description("Update a media label group from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <groupId>", "Label group ID.").requiredOption("--json <file>", "JSON file containing fields to update.").action(async (options, command) => {
+    const payload = updateLabelGroupSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("PATCH", `/v1/workspaces/${options.workspace}/media/label-groups/${options.id}`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:label-groups:delete")).description("Delete a media label group from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <groupId>", "Label group ID.").requiredOption("--json <file>", "JSON file containing mode: archive-labels or ungroup-labels.").action(async (options, command) => {
+    const payload = deleteLabelGroupSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("DELETE", `/v1/workspaces/${options.workspace}/media/label-groups/${options.id}`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:label-groups:reorder")).description("Reorder media label groups from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing the complete groupIds order.").action(async (options, command) => {
+    const payload = reorderLabelGroupsSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/label-groups/reorder`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:label-groups:add-labels")).description("Move media labels into a label group from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <groupId>", "Label group ID.").requiredOption("--json <file>", "JSON file containing labelIds.").action(async (options, command) => {
+    const payload = moveLabelsToGroupSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/label-groups/${options.id}/labels`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:label-groups:ungroup-labels")).description("Remove media labels from any label group from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing labelIds.").action(async (options, command) => {
+    const payload = moveLabelsToGroupSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/label-groups/ungroup-labels`, {
+        body: payload
+      })
+    );
+  });
   addConnectionOptions(program.command("media:bulk-archive")).description("Archive media in bulk from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing mediaIds.").action(async (options, command) => {
     const payload = mediaIdsSchema.parse(await readJsonFile(options.json));
     const client = createApiClient(resolveConfig(command));
@@ -2236,6 +2601,49 @@ function registerMediaCommands(program) {
       })
     );
   });
+  addConnectionOptions(program.command("media:bulk-restore")).description("Restore media from the Bin in bulk from a JSON payload file.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing mediaIds.").action(async (options, command) => {
+    const payload = mediaIdsSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/bulk-restore`, {
+        body: payload
+      })
+    );
+  });
+  addConnectionOptions(program.command("media:bulk-delete-forever")).description("Permanently delete binned media in bulk from a JSON payload file. This cannot be undone.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--json <file>", "JSON file containing mediaIds.").option("--yes", "Confirm permanent deletion of the explicit media IDs.").action(async (options, command) => {
+    if (!options.yes) {
+      throw new CliError("media:bulk-delete-forever requires --yes because it permanently deletes media.", {
+        code: "INVALID_OPTIONS"
+      });
+    }
+    const payload = mediaIdsSchema.parse(await readJsonFile(options.json));
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(
+      await client.request("POST", `/v1/workspaces/${options.workspace}/media/bulk-delete-forever`, {
+        body: payload
+      })
+    );
+  });
+}
+
+// src/commands/strategy.ts
+function registerStrategyCommands(program) {
+  addConnectionOptions(program.command("strategy:foundation")).description("Get the workspace strategy foundation brief.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/strategy/foundation`));
+  });
+  addConnectionOptions(program.command("strategy:goals")).description("List workspace strategy goals with computed status and current values.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/strategy/goals`));
+  });
+  addConnectionOptions(program.command("strategy:goals:metrics")).description("List the metric catalog available for strategy goals.").requiredOption("-w, --workspace <id>", "Workspace ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/strategy/goals/metrics`));
+  });
+  addConnectionOptions(program.command("strategy:goal")).description("Get one strategy goal with computed status and current value.").requiredOption("-w, --workspace <id>", "Workspace ID.").requiredOption("--id <goalId>", "Strategy goal ID.").action(async (options, command) => {
+    const client = createApiClient(resolveConfig(command));
+    writeRawJson(await client.request("GET", `/v1/workspaces/${options.workspace}/strategy/goals/${options.id}`));
+  });
 }
 
 // src/commands/taxonomy.ts
@@ -2289,11 +2697,14 @@ function createProgram() {
   registerMediaCommands(program);
   registerContentCommands(program);
   registerClientReviewCommands(program);
+  registerCampaignCommands(program);
+  registerStrategyCommands(program);
   registerTaxonomyCommands(program);
   registerHashtagCommands(program);
   registerAnalyticsCommands(program);
   registerInboxCommands(program);
   registerGridPlannerCommands(program);
+  registerBoostCommands(program);
   return program;
 }
 async function runCli(argv = process.argv) {
@@ -2318,8 +2729,16 @@ async function runCli(argv = process.argv) {
     process.exitCode = 1;
   }
 }
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  migrateLegacyCredentialFile();
+function isDirectInvocation() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isDirectInvocation()) {
   void runCli();
 }
 export {