@rolino/cli 0.4.0 → 0.5.0

package/dist/bin.cjs

@@ -34,7 +34,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@rolino/cli",
-  version: "0.4.0",
+  version: "0.5.0",
   description: "Agent-friendly command-line interface for Rolino",
   type: "module",
   license: "MIT",
@@ -91,9 +91,9 @@ var package_default = {
     dev: "tsx src/bin.ts"
   },
   dependencies: {
-    "@rolino/contracts": "0.4.0",
-    "@rolino/local-auth": "0.4.0",
-    "@rolino/sdk": "0.4.0",
+    "@rolino/contracts": "0.5.0",
+    "@rolino/local-auth": "0.5.0",
+    "@rolino/sdk": "0.5.0",
     commander: "^15.0.0",
     open: "^11.0.0"
   },
@@ -464,7 +464,6 @@ function formatPosts(data) {
   return ["ID	STATUS	SCHEDULED	CAPTION", ...rows].join("\n");
 }
 function formatPost(post) {
-  const queued = post.status === "PUBLISHING";
   return [
     `Post ${post.id}`,
     `Project: ${post.projectId}`,
@@ -473,11 +472,11 @@ function formatPost(post) {
     `Caption: ${post.caption || "-"}`,
     ...post.campaign ? [`Campaign: ${post.campaign.title} (${post.campaign.id})`] : [],
     ...post.scheduledAt ? [
-      `${queued ? "Queued for publishing" : "Scheduled"}: ${post.scheduledAt}${post.timezone ? ` (${post.timezone})` : ""}`
+      `Scheduled: ${post.scheduledAt}${post.timezone ? ` (${post.timezone})` : ""}`
     ] : [],
     ...post.publishedAt ? [`Published: ${post.publishedAt}`] : [],
     `Media: ${post.media.length}`,
-    `Destinations: ${post.destinations.map((destination) => `${destination.provider}:${queued && destination.status === "SCHEDULED" ? "QUEUED" : destination.status}`).join(", ") || "none"}`,
+    `Destinations: ${post.destinations.map((destination) => `${destination.provider}:${destination.deliveryMode}:${destination.stage}`).join(", ") || "none"}`,
     ...post.providerSettings?.TIKTOK ? [
       `TikTok: ${post.providerSettings.TIKTOK.postMode}, ${post.providerSettings.TIKTOK.privacyLevel ?? "visibility not set"}, settings ${post.providerSettings.TIKTOK.consentedAt ? "reviewed" : "not reviewed"}`
     ] : [],
@@ -488,7 +487,8 @@ function formatPost(post) {
 }
 function formatPostSchedulePending(pending) {
   return [
-    `YouTube schedule change pending for post ${pending.postId}.`,
+    `YouTube publish-time confirmation pending for post ${pending.postId}.`,
+    "Video upload: complete (the video remains private).",
     pending.message,
     `Mutation: ${pending.mutationId}`
   ].join("\n");
@@ -534,8 +534,14 @@ function formatPostSchedulePreview(preview) {
   return [
     `Schedule preview for post ${preview.post.id}`,
     `Current version: ${preview.post.version}`,
+    `Delivery mode: ${preview.deliveryMode}`,
     `Publish at: ${preview.schedule.scheduledAt} (${preview.schedule.timezone})`,
     `Destinations: ${preview.destinations.join(", ")}`,
+    ...preview.youtube ? [
+      "YouTube preparation: starts immediately as PRIVATE.",
+      `YouTube scheduled visibility: ${preview.youtube.publishVisibility}.`,
+      `YouTube confirmation: ${preview.youtube.confirmationMeaning}`
+    ] : [],
     ...preview.providerReconciliation ? [`Provider reconciliation: ${preview.providerReconciliation.message}`] : [],
     `Confirmation expires: ${preview.confirmation.expiresAt}`,
     `Confirmation token: ${preview.confirmation.token}`,
@@ -547,9 +553,10 @@ function formatPostPublishPreview(preview) {
   return [
     `Immediate publish preview for post ${preview.post.id}`,
     `Current version: ${preview.post.version}`,
+    `Delivery mode: ${preview.deliveryMode}`,
     `Destinations: ${preview.destinations.join(", ")}`,
     "Effect: confirmed execution queues these destinations for immediate publishing.",
-    ...preview.destinations.includes("YOUTUBE") ? ["YouTube effect: execution starts a resumable upload; PREPARING remains visible until upload, processing, and configured visibility are provider-confirmed."] : [],
+    ...preview.youtube ? [`YouTube effect: execution starts a resumable upload using ${preview.youtube.visibility}; it does not create a schedule. PREPARING remains visible until upload, processing, and visibility are provider-confirmed.`] : [],
     `Confirmation expires: ${preview.confirmation.expiresAt}`,
     `Confirmation token: ${preview.confirmation.token}`,
     ...attention.length ? ["Readiness notes:", ...attention.map((check) => `${check.status.toUpperCase()}	${check.provider ?? "POST"}	${check.code}	${check.message}`)] : ["All required readiness checks passed."]
@@ -562,6 +569,65 @@ function formatCalendarEvents(data) {
   const rows = data.items.map((event) => `${event.postId}	${event.scheduledAt}	${event.status}	${event.destinations.map((item) => item.provider).join(",") || "-"}	${event.title}`);
   return ["POST ID	SCHEDULED	STATUS	DESTINATIONS	TITLE", ...rows].join("\n");
 }
+function formatSeoOpportunities(data) {
+  if (!data.items.length) return "No active SEO tasks found.";
+  return [
+    "ID	DECISION	FORMAT	SCORE	TOPIC RELEVANCE	ACTION READINESS	TITLE",
+    ...data.items.map((item) => `${item.id}	${item.task.decision}	${item.task.primaryFormat}	${item.score}	${item.confidence.topicRelevance.label}	${item.confidence.actionReadiness.label}	${item.title}`)
+  ].join("\n");
+}
+function formatSeoOpportunity(opportunity) {
+  return [
+    `${opportunity.title} (${opportunity.id})`,
+    `Project: ${opportunity.projectId}`,
+    `Decision: ${opportunity.task.decision}`,
+    `Primary format: ${opportunity.task.primaryFormat}`,
+    `Objective: ${opportunity.task.objective}`,
+    `Next step: ${opportunity.task.nextStep}`,
+    `Priority: ${opportunity.score}/100`,
+    `Topic relevance: ${opportunity.confidence.topicRelevance.label}${opportunity.confidence.topicRelevance.score === null ? "" : ` (${opportunity.confidence.topicRelevance.score}/100)`}`,
+    `Topic relevance explanation: ${opportunity.confidence.topicRelevance.explanation}`,
+    `Action readiness: ${opportunity.confidence.actionReadiness.label}${opportunity.confidence.actionReadiness.score === null ? "" : ` (${opportunity.confidence.actionReadiness.score}/100)`}`,
+    `Action readiness explanation: ${opportunity.confidence.actionReadiness.explanation}`,
+    "",
+    opportunity.brief
+  ].join("\n");
+}
+function formatSeoReports(data) {
+  if (!data.items.length) return "No weekly SEO reports found.";
+  return [
+    "ID	PERIOD START	PERIOD END	STATUS	READY	RESEARCH	REJECTED	LEGACY",
+    ...data.items.map((item) => `${item.id}	${item.periodStart}	${item.periodEnd}	${item.completeness}	${item.readyTaskCount}	${item.researchTaskCount}	${item.rejectedFindingCount}	${item.legacy}`)
+  ].join("\n");
+}
+function formatSeoReport(report) {
+  return [
+    `Weekly SEO report ${report.id}`,
+    `Project: ${report.projectId}`,
+    `Period: ${report.periodStart} to ${report.periodEnd}`,
+    `Schedule: day ${report.deliveryDay} in ${report.timeZone}`,
+    `Status: ${report.completeness}`,
+    ...report.partialLabel ? [`Note: ${report.partialLabel}`] : [],
+    `Ready tasks: ${report.readyTaskCount}`,
+    `Research tasks: ${report.researchTaskCount}`,
+    `Rejected or filtered findings: ${report.rejectedFindingCount}`,
+    `Legacy report: ${report.legacy}`,
+    "",
+    ...report.opportunities.flatMap((item, index) => [
+      `${index + 1}. ${item.title}`,
+      `   Decision: ${item.task.decision}`,
+      `   Format: ${item.task.primaryFormat}`,
+      `   Objective: ${item.task.objective}`,
+      `   Next step: ${item.task.nextStep}`,
+      `   Topic relevance: ${item.confidence.topicRelevance.label}${item.confidence.topicRelevance.score === null ? "" : ` (${item.confidence.topicRelevance.score}/100)`}`,
+      `   Action readiness: ${item.confidence.actionReadiness.label}${item.confidence.actionReadiness.score === null ? "" : ` (${item.confidence.actionReadiness.score}/100)`}`
+    ]),
+    ...report.rejectedFindings.flatMap((item, index) => [
+      `Rejected ${index + 1}: ${item.query}`,
+      `   Reason: ${item.reason}`
+    ])
+  ].join("\n");
+}
 
 // src/mcp-setup.ts
 var import_node_child_process = require("child_process");
@@ -845,6 +911,21 @@ function postStatus(value) {
     `Status must be one of ${import_contracts2.PostStatusSchema.options.join(", ")}.`
   );
 }
+function seoOpportunityKind(value) {
+  const parsed = import_contracts2.SeoOpportunityKindSchema.safeParse(value.toUpperCase());
+  if (parsed.success) return parsed.data;
+  throw new import_commander.InvalidArgumentError(`SEO kind must be one of ${import_contracts2.SeoOpportunityKindSchema.options.join(", ")}.`);
+}
+function seoExpectedImpact(value) {
+  const parsed = import_contracts2.SeoExpectedImpactSchema.safeParse(value.toUpperCase());
+  if (parsed.success) return parsed.data;
+  throw new import_commander.InvalidArgumentError("SEO impact must be HIGH, MEDIUM, or LOW.");
+}
+function seoReportCompleteness(value) {
+  const parsed = import_contracts2.SeoReportCompletenessSchema.safeParse(value.toUpperCase());
+  if (parsed.success) return parsed.data;
+  throw new import_commander.InvalidArgumentError("Report status must be COMPLETE or PARTIAL.");
+}
 function projectType(value) {
   const parsed = import_contracts2.ProjectTypeSchema.safeParse(value.toUpperCase());
   if (parsed.success) return parsed.data;
@@ -972,6 +1053,10 @@ async function requireWriteConsent(options) {
     );
   }
 }
+function requireBlogExecutionConsent(options) {
+  if (options.yes || resolveFormat(options.global, options.runtime) !== "human") return;
+  throw new TypeError("This Blog execute command requires explicit consent. Review the confirmed operation and pass --yes.");
+}
 function formatMcpSetupPreview(result) {
   return [
     `Client: ${result.client === "codex" ? "Codex" : "Claude Code"}`,
@@ -1862,6 +1947,371 @@ async function runCli(argv = process.argv, overrides = {}) {
       }
     });
   });
+  const blog = program.command("blog").description("Read and manage Blog Studio");
+  const blogPublishing = blog.command("destinations").description("Inspect Blog publishing providers, destinations, and delivery attempts");
+  blogPublishing.command("providers").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog destinations providers", global, runtime, async action(context, client) {
+      const data = await client.blog.publishing.providers(local.project, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogPublishing.command("list").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog destinations list", global, runtime, async action(context, client) {
+      const data = await client.blog.publishing.destinations(local.project, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogPublishing.command("deliveries").requiredOption("--project <project-id>", "exact Rolino project ID").option("--article <article-id>", "filter by exact Blog article ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog destinations deliveries", global, runtime, async action(context, client) {
+      const data = await client.blog.publishing.deliveries(local.project, local.article, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogSetup = blog.command("setup").description("Inspect agent-first Blog setup readiness");
+  blogSetup.command("status").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog setup status", global, runtime, async action(context, client) {
+      const data = await client.blog.setup.status(local.project, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogSite = blog.command("site").description("Initialize or retry the Blog website import");
+  blogSite.command("import").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog site import", global, runtime, async action(context, client) {
+      const data = await client.blog.site.import(local.project, local.idempotencyKey, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2), [`rolino blog job ${data.id} --project ${local.project} --agent`]);
+    } });
+  });
+  blogSite.command("retry").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog site retry", global, runtime, async action(context, client) {
+      const data = await client.blog.site.retry(local.project, local.idempotencyKey, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2), [`rolino blog job ${data.id} --project ${local.project} --agent`]);
+    } });
+  });
+  blog.command("plans").description("List Blog Studio plans").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog plans", global, runtime, async action(context, client) {
+      const data = await client.blog.plans.list(local.project, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogPlan = blog.command("plan").description("Create, retry, and review a Blog cadence plan");
+  blogPlan.command("create").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--start <date>", "local start date as YYYY-MM-DD").requiredOption("--weekdays <days>", "comma-separated weekday names such as mon,wed,fri").option("--time-zone <zone>", "IANA time zone", "UTC").requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+    const weekdayMap = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+    const weekdays = local.weekdays.split(",").map((day) => weekdayMap[day.trim().toLowerCase()]).filter((day) => day !== void 0);
+    if (!weekdays.length || weekdays.length !== local.weekdays.split(",").length) throw new TypeError("--weekdays must contain comma-separated sun,mon,tue,wed,thu,fri,sat values.");
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog plan create", global, runtime, async action(context, client) {
+      const data = await client.blog.plans.create(local.project, { startsOn: local.start, weekdays, timeZone: local.timeZone }, local.idempotencyKey, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2), [`rolino blog job ${data.job.id} --project ${local.project} --agent`]);
+    } });
+  });
+  blogPlan.command("retry").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--plan <plan-id>", "exact Blog plan ID").requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog plan retry", global, runtime, async action(context, client) {
+      const data = await client.blog.plans.retry(local.project, local.plan, local.idempotencyKey, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogPlan.command("items").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--plan <plan-id>", "exact Blog plan ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog plan items", global, runtime, async action(context, client) {
+      const data = await client.blog.plans.items.list(local.project, local.plan, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogPlanItem = blogPlan.command("item").description("Accept or dismiss a reviewed Blog plan item");
+  for (const state of ["accept", "dismiss"]) {
+    blogPlanItem.command(state).requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--plan <plan-id>", "exact Blog plan ID").requiredOption("--item <item-id>", "exact plan item ID").requiredOption("--expected-state <state>", "state returned by the latest item read").requiredOption("--expected-version <version>", "version returned by the latest item read", Number).requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+      const global = program.opts();
+      commandExitCode = await execute({ command: `blog plan item ${state}`, global, runtime, async action(context, client) {
+        const data = await client.blog.plans.items.setState(local.project, local.plan, local.item, { state: state === "accept" ? "ACCEPTED" : "DISMISSED", expectedState: local.expectedState, expectedVersion: local.expectedVersion, idempotencyKey: local.idempotencyKey }, { requestId: context.requestId });
+        writeSuccess(context, data, JSON.stringify(data, null, 2));
+      } });
+    });
+  }
+  const blogArticle = blog.command("article").description("Create an editable Blog article from an accepted item");
+  blogArticle.command("create").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--plan <plan-id>", "exact Blog plan ID").requiredOption("--item <item-id>", "exact accepted item ID").requiredOption("--expected-version <version>", "version returned by the latest item read", Number).requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog article create", global, runtime, async action(context, client) {
+      const data = await client.blog.plans.items.createArticle(local.project, local.plan, local.item, { expectedState: "ACCEPTED", expectedVersion: local.expectedVersion, idempotencyKey: local.idempotencyKey }, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogConnection = blog.command("connection").description("Configure and verify the server-only Next.js Blog connection");
+  blogConnection.command("status").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog connection status", global, runtime, async action(context, client) {
+      const data = await client.blog.connection.status(local.project, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const addConnectionOptions = (command, execute2) => {
+    command.requiredOption("--project <project-id>", "exact Rolino project ID").option("--endpoint <url>", "same-host signed revalidation endpoint").option("--credential-action <action>", "KEEP, CREATE, ROTATE, or REVOKE", "KEEP").option("--credential-id <id>", "credential to rotate or revoke").option("--secret-action <action>", "KEEP, CREATE, or ROTATE", "KEEP");
+    if (execute2) command.requiredOption("--confirmation-token <token>", "short-lived token returned by preview").requiredOption("--idempotency-key <key>", "stable retry key").option("--yes", "confirm the exact connection change");
+    return command;
+  };
+  addConnectionOptions(blogConnection.command("preview"), false).action(async (local) => {
+    const input = { endpoint: local.endpoint ?? null, credentialAction: local.credentialAction.toUpperCase(), credentialId: local.credentialId ?? null, secretAction: local.secretAction.toUpperCase() };
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog connection preview", global, runtime, async action(context, client) {
+      const data = await client.blog.connection.preview(local.project, input, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  addConnectionOptions(blogConnection.command("execute"), true).action(async (local) => {
+    const input = { endpoint: local.endpoint ?? null, credentialAction: local.credentialAction.toUpperCase(), credentialId: local.credentialId ?? null, secretAction: local.secretAction.toUpperCase() };
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog connection execute", global, runtime, async action(context, client) {
+      await requireWriteConsent({ yes: local.yes, global, runtime, preview: `Apply the previewed Blog connection change for project ${local.project}? One-time secrets may be returned and must stay server-only.` });
+      const data = await client.blog.connection.execute(local.project, { ...input, confirmationToken: local.confirmationToken, idempotencyKey: local.idempotencyKey }, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogConnection.command("test").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--idempotency-key <key>", "stable retry key").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog connection test", global, runtime, async action(context, client) {
+      const data = await client.blog.connection.test(local.project, local.idempotencyKey, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogArticles = blog.command("articles").description("Read and edit Blog Studio articles");
+  blogArticles.command("list").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog articles list", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.list(local.project, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogArticles.command("show").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog articles show", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.get(local.project, articleId, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogArticles.command("update").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--input <json-file>", "complete Blog draft JSON file").option("--yes", "confirm the draft save").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog articles update", global, runtime, async action(context, client) {
+      const draft = import_contracts2.AgentBlogDraftUpdateSchema.parse(JSON.parse(await (0, import_promises2.readFile)((0, import_node_path2.resolve)(runtime.cwd, local.input), "utf8")));
+      await requireWriteConsent({ yes: local.yes, global, runtime, preview: `Save a new immutable Blog draft revision?
+Project: ${local.project}
+Article: ${articleId}
+This will not publish.` });
+      const data = await client.blog.articles.updateDraft(local.project, articleId, draft, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogArticles.command("generate").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").option("--idempotency-key <key>", "stable retry key; defaults to request ID").option("--yes", "confirm the generation request").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog articles generate", global, runtime, async action(context, client) {
+      await requireWriteConsent({ yes: local.yes, global, runtime, preview: `Queue durable Blog article generation?
+Project: ${local.project}
+Article: ${articleId}` });
+      const data = await client.blog.articles.generate(local.project, articleId, local.idempotencyKey ?? context.requestId, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogImages = blog.command("images").description("Create and review Blog images with blog:write; cannot approve or publish");
+  blogImages.command("generate").description("Queue one exact-revision featured image with blog:write; cannot approve or publish").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "exact Blog revision ID").option("--editorial-brief <text>", "bounded visual direction; provider controls stay on the server").option("--idempotency-key <key>", "stable retry key; defaults to request ID").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog images generate", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.generateImage(local.project, articleId, { revisionId: local.revision, idempotencyKey: local.idempotencyKey ?? context.requestId, editorialBrief: local.editorialBrief }, { requestId: context.requestId });
+      writeSuccess(context, data, `Blog image generation queued.
+Image: ${data.image.id}
+Job: ${data.job.id}`);
+    } });
+  });
+  blogImages.command("upload").description("Upload one JPEG, PNG, or WebP for an exact Blog revision with blog:write; cannot approve or publish").argument("<article-id>").argument("<file-path>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "exact Blog revision ID").requiredOption("--alt-text <text>", "reviewable image alt text").action(async (articleId, filePath, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog images upload", global, runtime, async action(context, client) {
+      const absolutePath = (0, import_node_path2.resolve)(runtime.cwd, filePath);
+      const details = await (0, import_promises2.stat)(absolutePath).catch(() => null);
+      if (!details?.isFile()) throw new TypeError("The Blog image path must point to a readable file.");
+      const contentTypes = { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp" };
+      const extension = (0, import_node_path2.extname)(absolutePath).toLowerCase();
+      const contentType = contentTypes[extension];
+      if (!contentType) throw new TypeError("Use a JPEG, PNG, or WebP Blog image.");
+      const body = await (0, import_node_fs2.openAsBlob)(absolutePath, { type: contentType });
+      const data = await client.blog.articles.uploadImage(local.project, articleId, { revisionId: local.revision, fileName: (0, import_node_path2.basename)(absolutePath), contentType, fileSize: details.size, altText: local.altText, body }, { requestId: context.requestId });
+      writeSuccess(context, data, `Blog image uploaded for review.
+Image: ${data.id}
+State: ${data.state}`);
+    } });
+  });
+  blogImages.command("review").description("Review one exact Blog image with blog:write; does not approve the article or publish").argument("<article-id>").argument("<image-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--decision <decision>", "APPROVED or REJECTED").requiredOption("--expected-version <version>", "current image version", positiveInteger).option("--alt-text <text>", "final image alt text; required by the server for approval").option("--idempotency-key <key>", "stable retry key; defaults to request ID").action(async (articleId, imageId, local) => {
+    const decision = local.decision.toUpperCase();
+    if (decision !== "APPROVED" && decision !== "REJECTED") throw new TypeError("--decision must be APPROVED or REJECTED.");
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog images review", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.reviewImage(local.project, articleId, imageId, { decision, expectedVersion: local.expectedVersion, altText: local.altText ?? "", idempotencyKey: local.idempotencyKey ?? context.requestId }, { requestId: context.requestId });
+      writeSuccess(context, data, `Blog image review saved.
+Image: ${data.id}
+State: ${data.state}`);
+    } });
+  });
+  const blogApprove = blog.command("approve").description("Approve one exact Blog bundle with blog:approve; cannot publish");
+  blogApprove.command("preview").description("Preview one exact approval bundle with blog:approve; creates a confirmation but cannot publish").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "exact Blog revision ID").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog approve preview", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.previewApproval(local.project, articleId, { revisionId: local.revision }, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogApprove.command("execute").description("Approve the confirmed exact bundle with blog:approve; separate blog:publish access is still required").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "same exact revision used for preview").requiredOption("--confirmation-token <token>", "short-lived token returned by preview").requiredOption("--idempotency-key <key>", "stable retry key").option("--yes", "confirm exact bundle approval").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog approve execute", global, runtime, async action(context, client) {
+      requireBlogExecutionConsent({ yes: local.yes, global, runtime });
+      const data = await client.blog.articles.executeApproval(local.project, articleId, { revisionId: local.revision, confirmationToken: local.confirmationToken, idempotencyKey: local.idempotencyKey }, { requestId: context.requestId });
+      writeSuccess(context, data, `Exact Blog bundle approved.
+Revision: ${data.revisionId}
+Publishing still requires blog:publish.`);
+    } });
+  });
+  const blogSchedule = blog.command("schedule").description("Schedule exact approved Blog bundles with blog:publish; does not grant approval");
+  const addScheduleOptions = (command, executeSchedule) => {
+    command.argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "exact approved Blog revision ID").requiredOption("--at <iso>", "future ISO date-time with UTC offset").requiredOption("--timezone <iana>", "explicit IANA timezone").option("--destination <destination-id...>", "exact destination IDs; defaults to the current primary");
+    if (executeSchedule) command.requiredOption("--confirmation-token <token>", "short-lived token returned by preview").requiredOption("--idempotency-key <key>", "stable retry key").option("--yes", "confirm future external publication");
+    return command;
+  };
+  addScheduleOptions(blogSchedule.command("preview").description("Preview an exact future Blog schedule with blog:publish; does not publish now"), false).action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog schedule preview", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.previewSchedule(local.project, articleId, { revisionId: local.revision, scheduledAt: local.at, timezone: local.timezone, destinationIds: local.destination }, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  addScheduleOptions(blogSchedule.command("execute").description("Execute a confirmed future Blog schedule with blog:publish; causes future external publication"), true).action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog schedule execute", global, runtime, async action(context, client) {
+      requireBlogExecutionConsent({ yes: local.yes, global, runtime });
+      const data = await client.blog.articles.executeSchedule(local.project, articleId, { revisionId: local.revision, scheduledAt: local.at, timezone: local.timezone, destinationIds: local.destination, confirmationToken: local.confirmationToken, idempotencyKey: local.idempotencyKey }, { requestId: context.requestId });
+      writeSuccess(context, data, `Blog article scheduled.
+Time: ${data.scheduledAt}
+Timezone: ${data.timezone}`);
+    } });
+  });
+  const blogScheduleCancel = blogSchedule.command("cancel").description("Cancel one future Blog schedule with blog:publish; never unpublishes a live article");
+  blogScheduleCancel.command("preview").description("Preview exact schedule cancellation with blog:publish; does not unpublish").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog schedule cancel preview", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.previewScheduleCancellation(local.project, articleId, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogScheduleCancel.command("execute").description("Cancel the confirmed future schedule with blog:publish; never unpublishes a live article").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--confirmation-token <token>", "short-lived token returned by preview").requiredOption("--idempotency-key <key>", "stable retry key").option("--yes", "confirm schedule cancellation").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog schedule cancel execute", global, runtime, async action(context, client) {
+      requireBlogExecutionConsent({ yes: local.yes, global, runtime });
+      const data = await client.blog.articles.executeScheduleCancellation(local.project, articleId, { confirmationToken: local.confirmationToken, idempotencyKey: local.idempotencyKey }, { requestId: context.requestId });
+      writeSuccess(context, data, `Future Blog schedule canceled.
+Article: ${data.articleId}
+A live article was not unpublished.`);
+    } });
+  });
+  blog.command("job").argument("<job-id>").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (jobId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog job", global, runtime, async action(context, client) {
+      const data = await client.blog.jobs.get(local.project, jobId, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const blogPublish = blog.command("publish").description("Preview or execute exact approved Blog publication");
+  blogPublish.command("preview").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "exact user-approved revision ID").option("--destination <destination-id...>", "exact destination IDs; defaults to the current primary").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog publish preview", global, runtime, async action(context, client) {
+      const data = await client.blog.articles.previewPublish(local.project, articleId, local.revision, { requestId: context.requestId }, local.destination);
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  blogPublish.command("execute").argument("<article-id>").requiredOption("--project <project-id>", "exact Rolino project ID").requiredOption("--revision <revision-id>", "same exact revision used for preview").requiredOption("--confirmation-token <token>", "short-lived token returned by preview").option("--destination <destination-id...>", "same exact destination IDs used for preview").option("--idempotency-key <key>", "stable retry key; defaults to request ID").option("--yes", "confirm publication").action(async (articleId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({ command: "blog publish execute", global, runtime, async action(context, client) {
+      await requireWriteConsent({ yes: local.yes, global, runtime, preview: `Publish the exact approved Blog revision?
+Project: ${local.project}
+Article: ${articleId}
+Revision: ${local.revision}` });
+      const data = await client.blog.articles.executePublish(local.project, articleId, { revisionId: local.revision, destinationIds: local.destination, confirmationToken: local.confirmationToken, idempotencyKey: local.idempotencyKey ?? context.requestId }, { requestId: context.requestId });
+      writeSuccess(context, data, JSON.stringify(data, null, 2));
+    } });
+  });
+  const seo = program.command("seo").description("Read authorized SEO opportunities and weekly reports");
+  const seoOpportunities = seo.command("opportunities").description("Read accepted SEO opportunities");
+  seoOpportunities.command("list").description("List bounded SEO opportunities").requiredOption("--project <project-id>", "exact Rolino project ID").option("--limit <number>", "maximum opportunities to return", (value) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 50) {
+      throw new import_commander.InvalidArgumentError("Limit must be an integer from 1 to 50.");
+    }
+    return parsed;
+  }).option("--cursor <cursor>", "continue from an SEO opportunity cursor").option("--kind <kind>", "filter by exact SEO opportunity kind", seoOpportunityKind).option("--impact <impact>", "filter by HIGH, MEDIUM, or LOW impact", seoExpectedImpact).action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({
+      command: "seo opportunities list",
+      global,
+      runtime,
+      async action(context, client) {
+        const data = await client.seo.opportunities.list(local.project, {
+          limit: local.limit,
+          cursor: local.cursor,
+          kind: local.kind,
+          expectedImpact: local.impact
+        }, { requestId: context.requestId });
+        writeSuccess(context, data, formatSeoOpportunities(data), data.items.slice(0, 3).map((item) => `rolino seo opportunities show ${item.id} --project ${local.project} --agent`));
+      }
+    });
+  });
+  seoOpportunities.command("show").description("Show one canonical SEO opportunity task").argument("<opportunity-id>").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (opportunityId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({
+      command: "seo opportunities show",
+      global,
+      runtime,
+      async action(context, client) {
+        const opportunity = await client.seo.opportunities.get(local.project, opportunityId, { requestId: context.requestId });
+        writeSuccess(context, opportunity, formatSeoOpportunity(opportunity));
+      }
+    });
+  });
+  const seoReports = seo.command("reports").description("Read immutable weekly SEO report snapshots");
+  seoReports.command("list").description("List bounded weekly SEO reports").requiredOption("--project <project-id>", "exact Rolino project ID").option("--limit <number>", "maximum reports to return", (value) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 26) {
+      throw new import_commander.InvalidArgumentError("Limit must be an integer from 1 to 26.");
+    }
+    return parsed;
+  }).option("--cursor <cursor>", "continue from an SEO report cursor").option("--status <status>", "filter by COMPLETE or PARTIAL", seoReportCompleteness).action(async (local) => {
+    const global = program.opts();
+    commandExitCode = await execute({
+      command: "seo reports list",
+      global,
+      runtime,
+      async action(context, client) {
+        const data = await client.seo.reports.list(local.project, {
+          limit: local.limit,
+          cursor: local.cursor,
+          completeness: local.status
+        }, { requestId: context.requestId });
+        writeSuccess(context, data, formatSeoReports(data), data.items.slice(0, 3).map((item) => `rolino seo reports show ${item.id} --project ${local.project} --agent`));
+      }
+    });
+  });
+  seoReports.command("show").description("Show one weekly SEO report snapshot").argument("<report-id>").requiredOption("--project <project-id>", "exact Rolino project ID").action(async (reportId, local) => {
+    const global = program.opts();
+    commandExitCode = await execute({
+      command: "seo reports show",
+      global,
+      runtime,
+      async action(context, client) {
+        const report = await client.seo.reports.get(local.project, reportId, { requestId: context.requestId });
+        writeSuccess(context, report, formatSeoReport(report));
+      }
+    });
+  });
   program.command("doctor").description("Check configuration, compatibility, and authentication").action(async () => {
     const global = program.opts();
     commandExitCode = await execute({