@siteoshq/cli 2.5.0 → 2.6.0

package/dist/cli.js

@@ -1506,7 +1506,7 @@ var OverviewSchema = z4.object({
 });
 function createProjectApi(input) {
   const origin = resolveSiteOSAuthBaseUrl(input.env);
-  async function request(path29, schema, body, method) {
+  async function request(path30, schema, body, method) {
     const scope = body === void 0 ? "projects:workspace:read" : "projects:workspace:write";
     const grant = await input.grants.acquire({
       audience: "siteos-projects",
@@ -1520,7 +1520,7 @@ function createProjectApi(input) {
         message: "SiteOS API access is unavailable."
       });
     const response = await input.fetchImpl(
-      `${origin}/api/projects/v1/projects${path29}`,
+      `${origin}/api/projects/v1/projects${path30}`,
       {
         method: method ?? (body === void 0 ? "GET" : "POST"),
         headers: {
@@ -8418,11 +8418,301 @@ async function runServiceCommand(service, options) {
   }
 }
 
-// src/services/analytics-command.ts
+// src/services/analytics-google-csv.ts
+import { z as z14 } from "zod";
+var table = z14.object({
+  dimensions: z14.array(z14.string()),
+  metrics: z14.array(z14.object({ name: z14.string() })),
+  rows: z14.array(
+    z14.object({ dimensions: z14.array(z14.string()), metrics: z14.array(z14.string()) })
+  )
+});
+function googleReportCsv(value, fetchedAt) {
+  const report = z14.object({
+    request: z14.object({
+      kind: z14.string(),
+      propertyId: z14.string(),
+      streamId: z14.string(),
+      startDate: z14.string(),
+      endDate: z14.string(),
+      filters: z14.array(z14.unknown()),
+      minuteRange: z14.unknown().optional(),
+      comparison: z14.object({ startDate: z14.string(), endDate: z14.string() }).optional()
+    }).passthrough(),
+    timeZone: z14.string(),
+    limitations: z14.array(z14.string()),
+    quality: z14.unknown(),
+    table,
+    previous: table.optional()
+  }).parse(value);
+  const escape = (v) => `"${(/^[\s]*[=+\-@\t\r]/u.test(v) ? "'" : "") + v.replaceAll('"', '""')}"`;
+  const rows = [
+    ["Report", report.request.kind],
+    ["Definition", JSON.stringify(report.request)],
+    ["Property", report.request.propertyId],
+    ["Stream", report.request.streamId],
+    ["From", report.request.startDate],
+    ["To", report.request.endDate],
+    ["Timezone", report.timeZone],
+    ["Fetched at", fetchedAt ?? ""],
+    ["Filters", JSON.stringify(report.request.filters)],
+    ["Minute boundaries", JSON.stringify(report.request.minuteRange ?? null)],
+    ["Limitations", report.limitations.join(", ")],
+    ["Quality", JSON.stringify(report.quality)],
+    []
+  ];
+  const add = (t, label) => {
+    rows.push(
+      [label],
+      [...t.dimensions, ...t.metrics.map((m) => m.name)],
+      ...t.rows.map((r) => [...r.dimensions, ...r.metrics])
+    );
+  };
+  add(report.table, "Selected period");
+  if (report.previous) {
+    rows.push(
+      ["Comparison from", report.request.comparison?.startDate ?? ""],
+      ["Comparison to", report.request.comparison?.endDate ?? ""]
+    );
+    add(report.previous, "Comparison period");
+  }
+  return rows.map((r) => r.map(escape).join(",")).join("\r\n");
+}
+
+// src/services/analytics-google-command.ts
 import { readFile as readFile16, stat as stat2 } from "fs/promises";
 import path25 from "path";
 import { parseArgs as parseArgs4 } from "util";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
+var GOOGLE_ANALYTICS_HELP = `Read GA4 reports in the selected Project environment.
+
+Usage:
+  siteos analytics ga4 report [--period <today|yesterday|24h|7d|28d|month|last-month|custom>] [--from <date>] [--to <date>] [--compare <previous|year|none>] [--filters <json>] [--section <totals|trend|events|channels|sources|pages|countries|devices|quality>] [--offset <number>] [--limit <1..100>] [--refresh] [--environment <slug>] [--json]
+  siteos analytics ga4 realtime [--filters <json>] [--environment <slug>] [--json]
+  siteos analytics ga4 explore --file <selection.json> [--refresh] [--environment <slug>] [--json]
+  siteos analytics ga4 export --file <selection.json> [--environment <slug>]
+  siteos analytics ga4 saved list [--environment <slug>] [--json]
+  siteos analytics ga4 saved save --file <saved-report.json> [--environment <slug>] [--json]
+  siteos analytics ga4 saved remove <id> --revision <number> [--environment <slug>] [--json]
+
+A missing or stale report is queued in the shared cache; rerun to read completion.
+Exploration selections support campaigns, registered event dimensions, funnels and cohorts.
+Export writes CSV to stdout from a completed cached snapshot. It does not wait for Google.
+Saved report writes require an owner/admin and analytics:reports:write.
+No command connects Google, changes tracking or enables notifications.`;
+async function runAnalyticsGoogleCommand(options) {
+  const json = options.args.includes("--json");
+  if (options.args.length <= 1 || options.args.includes("--help"))
+    return { exitCode: 0, stdout: GOOGLE_ANALYTICS_HELP };
+  try {
+    const { values, positionals } = parseArgs4({
+      args: options.args.slice(1),
+      allowPositionals: true,
+      strict: true,
+      options: {
+        json: { type: "boolean" },
+        environment: { type: "string" },
+        period: { type: "string" },
+        from: { type: "string" },
+        to: { type: "string" },
+        compare: { type: "string" },
+        filters: { type: "string" },
+        section: { type: "string" },
+        offset: { type: "string" },
+        limit: { type: "string" },
+        file: { type: "string" },
+        revision: { type: "string" },
+        refresh: { type: "boolean" }
+      }
+    });
+    const action = positionals[0];
+    const sub = positionals[1];
+    const operations = {
+      report: {
+        args: 1,
+        flags: [
+          "period",
+          "from",
+          "to",
+          "compare",
+          "filters",
+          "refresh",
+          "section",
+          "offset",
+          "limit"
+        ]
+      },
+      realtime: { args: 1, flags: ["filters"] },
+      explore: { args: 1, flags: ["file", "refresh"] },
+      export: { args: 1, flags: ["file"] },
+      "saved list": { args: 2, flags: [] },
+      "saved save": { args: 2, flags: ["file"], write: true },
+      "saved remove": { args: 3, flags: ["revision"], write: true }
+    };
+    const operation = operations[action === "saved" ? `${action} ${sub}` : action ?? ""];
+    if (!operation || positionals.length !== operation.args || Object.keys(values).some(
+      (k) => !["json", "environment", ...operation.flags].includes(k)
+    ))
+      throw new Error(
+        "Invalid GA4 operation or flags. Run siteos analytics ga4 --help."
+      );
+    const context = await commonServiceContext(
+      options,
+      "analytics",
+      values.environment
+    );
+    if (!context) throw new Error("Select a SiteOS Project first.");
+    const runtime = commonProjectRuntime(options);
+    const scope = operation.write ? "analytics:reports:write" : "analytics:workspace:read";
+    const grant = await runtime.grants.acquire({
+      audience: "siteos-analytics",
+      scopes: [scope]
+    });
+    if (grant.grant.audience !== "siteos-analytics" || grant.grant.organizationId !== context.overview.project.organizationId || grant.grant.scopes.length !== 1 || grant.grant.scopes[0] !== scope)
+      throw new Error(
+        "The Analytics grant does not match this Project and operation."
+      );
+    if (!options.fetchImpl)
+      throw new Error("SiteOS API access is unavailable.");
+    const send = async (suffix, method = "GET", body) => {
+      const response = await options.fetchImpl(
+        `${runtime.api.origin}/api/analytics/v1/resources/${encodeURIComponent(context.resourceId)}/ga4${suffix}`,
+        {
+          method,
+          headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${grant.accessToken}`,
+            ...body ? { "Content-Type": "application/json" } : {}
+          },
+          ...body ? { body: JSON.stringify(body) } : {},
+          signal: AbortSignal.timeout(3e4)
+        }
+      );
+      const value = await response.json();
+      if (!response.ok) {
+        const error = z15.object({
+          error: z15.object({ code: z15.string(), message: z15.string().max(500) })
+        }).safeParse(value);
+        throw new SiteOSAuthApiError({
+          code: error.success ? error.data.error.code : "ANALYTICS_REQUEST_FAILED",
+          message: error.success ? error.data.error.message : "The GA4 request failed.",
+          status: response.status
+        });
+      }
+      return z15.object({
+        contractVersion: z15.literal(1),
+        resourceId: z15.literal(context.resourceId)
+      }).passthrough().parse(value);
+    };
+    const file = async () => {
+      if (!values.file)
+        throw new Error("Provide --file with a report definition.");
+      const name = path25.resolve(options.cwd ?? process.cwd(), values.file);
+      if ((await stat2(name)).size > 16384)
+        throw new Error("Definition exceeds 16 KiB.");
+      const text = await readFile16(name, "utf8");
+      if (Buffer.byteLength(text) > 16384)
+        throw new Error("Definition exceeds 16 KiB.");
+      return z15.record(z15.unknown()).parse(JSON.parse(text));
+    };
+    let result;
+    if (action === "saved") {
+      result = sub === "list" ? await send("/saved") : sub === "save" ? await send("/saved", "POST", await file()) : await send("/saved", "DELETE", {
+        id: z15.string().uuid().parse(positionals[2]),
+        revision: z15.number().int().positive().parse(Number(values.revision))
+      });
+    } else {
+      const base = await send("");
+      const binding = z15.object({ revision: z15.number().int().positive(), state: z15.string() }).parse(base.binding);
+      if (binding.state === "disconnected")
+        throw new Error("Connect GA4 in Analytics Setup first.");
+      if (action === "report") {
+        const params = new URLSearchParams({ period: values.period ?? "7d" });
+        for (const k of [
+          "from",
+          "to",
+          "compare",
+          "filters",
+          "section",
+          "offset",
+          "limit"
+        ])
+          if (values[k] && values[k] !== "none") params.set(k, values[k]);
+        if (!values.compare) params.set("compare", "previous");
+        result = await send(`?${params}`);
+        const cached = result.query;
+        if (result.range && ((values.section ? !result.report || result.stale : !cached || cached.state === "ready" && cached.stale) || values.refresh)) {
+          await send("/report", "POST", {
+            period: 7,
+            revision: binding.revision,
+            filters: values.filters ? JSON.parse(values.filters) : [],
+            range: Object.fromEntries(
+              [...params].filter(
+                ([k]) => ["period", "from", "to", "compare"].includes(k)
+              )
+            ),
+            refresh: values.refresh ?? false
+          });
+          result = await send(`?${params}`);
+        }
+      } else if (action === "realtime") {
+        const filters2 = values.filters ? JSON.parse(values.filters) : [];
+        const params = new URLSearchParams({
+          filters: JSON.stringify(filters2)
+        });
+        result = await send(`/realtime?${params}`);
+        const live = result.realtime;
+        if (!live?.report || live.stale) {
+          await send("/realtime", "POST", {
+            revision: binding.revision,
+            filters: filters2
+          });
+          result = await send(`/realtime?${params}`);
+        }
+      } else {
+        const selection = await file();
+        const suffix = `/explore?${new URLSearchParams({ selection: JSON.stringify(selection) })}`;
+        result = await send(suffix);
+        const query = result.query;
+        if (action === "export") {
+          if (!query?.report)
+            throw new Error(
+              "No cached report. Run ga4 explore first, then export after it completes."
+            );
+          const csv = googleReportCsv(query.report, query.fetchedAt ?? null);
+          return {
+            exitCode: 0,
+            stdout: csv
+          };
+        }
+        if (!query || query.state === "ready" && query.stale || values.refresh) {
+          await send("/explore", "POST", {
+            selection,
+            revision: binding.revision,
+            refresh: values.refresh ?? false
+          });
+          result = await send(suffix);
+        }
+      }
+    }
+    return { exitCode: 0, stdout: JSON.stringify(result, null, 2) };
+  } catch (cause) {
+    const error = {
+      code: cause instanceof SiteOSAuthApiError ? cause.code : "ANALYTICS_COMMAND_FAILED",
+      message: cause instanceof z15.ZodError ? "The input or server response does not match the GA4 contract." : cause instanceof Error ? cause.message : "GA4 request failed."
+    };
+    return {
+      exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
+      ...json ? { stdout: JSON.stringify({ error }) } : { stderr: error.message }
+    };
+  }
+}
+
+// src/services/analytics-command.ts
+import { readFile as readFile17, stat as stat3 } from "fs/promises";
+import path26 from "path";
+import { parseArgs as parseArgs5 } from "util";
+import { z as z16 } from "zod";
 var ANALYTICS_HELP = `Set up website Analytics in the selected Project environment.
 
 Usage:
@@ -8444,6 +8734,7 @@ Usage:
   siteos analytics funnels create --file <funnel.json> [--environment <slug>] [--json]
   siteos analytics funnels archive <id> [--environment <slug>] [--json]
   siteos analytics monitoring prepare [--environment <slug>] [--json]
+${GOOGLE_ANALYTICS_HELP.split("Usage:\n")[1].split("\n\n")[0]}
 
 Connect first: siteos project connect analytics. Cookie and Trace are optional.
 Use project environment use <slug> to select an environment; no resource fallback is allowed.
@@ -8453,27 +8744,27 @@ Settings require an owner/admin, the current revision and at least one change.
 Catalog files are bounded JSON using the documented event/campaign/goal/funnel contracts.
 Monitoring preparation creates a Trace draft only; publication remains a separate operation.
 Analytics is Unlimited during early access. No synthetic events are sent by these commands.`;
-var EventInput = z14.object({
-  name: z14.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
-  label: z14.string().trim().min(1).max(80),
-  properties: z14.record(
-    z14.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
-    z14.array(
-      z14.string().min(1).max(80).regex(/^[a-zA-Z0-9 _./:-]+$/u)
+var EventInput = z16.object({
+  name: z16.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
+  label: z16.string().trim().min(1).max(80),
+  properties: z16.record(
+    z16.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
+    z16.array(
+      z16.string().min(1).max(80).regex(/^[a-zA-Z0-9 _./:-]+$/u)
     ).min(1).max(20)
   ).refine((v) => Object.keys(v).length <= 8)
 }).strict();
-var Resource = z14.object({
-  id: z14.string(),
-  organizationId: z14.string(),
-  name: z14.string(),
-  slug: z14.string(),
-  origin: z14.string().url(),
-  publicKey: z14.string(),
-  revision: z14.number().int().positive(),
-  enabled: z14.boolean(),
-  cookieEvents: z14.boolean(),
-  minimalRealtime: z14.boolean()
+var Resource = z16.object({
+  id: z16.string(),
+  organizationId: z16.string(),
+  name: z16.string(),
+  slug: z16.string(),
+  origin: z16.string().url(),
+  publicKey: z16.string(),
+  revision: z16.number().int().positive(),
+  enabled: z16.boolean(),
+  cookieEvents: z16.boolean(),
+  minimalRealtime: z16.boolean()
 });
 var readKeys = [
   "days",
@@ -8518,10 +8809,14 @@ var pick = (value, keys) => Object.fromEntries(
 );
 async function runAnalyticsCommand(options) {
   if (!options.args.length || options.args.some((v) => ["--help", "-h"].includes(v)))
-    return { exitCode: 0, stdout: ANALYTICS_HELP };
+    return {
+      exitCode: 0,
+      stdout: ANALYTICS_HELP + "\n\n" + GOOGLE_ANALYTICS_HELP
+    };
+  if (options.args[0] === "ga4") return runAnalyticsGoogleCommand(options);
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs4({
+    const { positionals, values } = parseArgs5({
       args: options.args,
       strict: true,
       allowPositionals: true,
@@ -8603,7 +8898,7 @@ async function runAnalyticsCommand(options) {
       throw new Error("Use --days 1, 7 or 28.");
     if (values.country && !/^(?:[A-Z]{2}|unknown)$/u.test(values.country))
       throw new Error("Use an uppercase ISO country code or unknown.");
-    if (values.campaign) z14.string().uuid().parse(values.campaign);
+    if (values.campaign) z16.string().uuid().parse(values.campaign);
     const setting = route === "settings set", creating = positionals[1] === "create", archive = positionals[1] === "archive";
     let body;
     if (setting) {
@@ -8627,10 +8922,10 @@ async function runAnalyticsCommand(options) {
     } else if (creating) {
       if (!values.file)
         throw new Error("Creation requires --file with a JSON definition.");
-      const filename = path25.resolve(options.cwd ?? process.cwd(), values.file);
-      if ((await stat2(filename)).size > 16384)
+      const filename = path26.resolve(options.cwd ?? process.cwd(), values.file);
+      if ((await stat3(filename)).size > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
-      const text = await readFile16(filename, "utf8");
+      const text = await readFile17(filename, "utf8");
       if (Buffer.byteLength(text) > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
       let definition;
@@ -8639,9 +8934,9 @@ async function runAnalyticsCommand(options) {
       } catch {
         throw new Error("The definition must contain valid JSON.");
       }
-      body = z14.record(z14.unknown()).parse(definition);
+      body = z16.record(z16.unknown()).parse(definition);
       if (action === "events") body = EventInput.parse(body);
-    } else if (archive) body = { id: z14.string().uuid().parse(positionals[2]) };
+    } else if (archive) body = { id: z16.string().uuid().parse(positionals[2]) };
     const context = await commonServiceContext(
       options,
       "analytics",
@@ -8688,8 +8983,8 @@ async function runAnalyticsCommand(options) {
     );
     const value = await response.json();
     if (!response.ok) {
-      const error = z14.object({
-        error: z14.object({ code: z14.string(), message: z14.string().max(500) })
+      const error = z16.object({
+        error: z16.object({ code: z16.string(), message: z16.string().max(500) })
       }).safeParse(value);
       throw new SiteOSAuthApiError({
         code: error.success ? error.data.error.code : "ANALYTICS_REQUEST_FAILED",
@@ -8697,9 +8992,9 @@ async function runAnalyticsCommand(options) {
         status: response.status
       });
     }
-    const record = z14.object({
-      contractVersion: z14.literal(1),
-      resourceId: z14.literal(context.resourceId)
+    const record = z16.object({
+      contractVersion: z16.literal(1),
+      resourceId: z16.literal(context.resourceId)
     }).passthrough().parse(value);
     let output;
     if (setting) {
@@ -8718,16 +9013,16 @@ async function runAnalyticsCommand(options) {
           throw new Error("The saved event does not match this definition.");
       } else
         output = {
-          id: z14.string().uuid().parse(record.id),
+          id: z16.string().uuid().parse(record.id),
           ...pick(
             record,
             action === "campaigns" ? ["label", "source", "medium", "campaign"] : action === "goals" ? ["label", "match"] : ["label", "steps"]
           )
         };
     } else if (archive)
-      output = { archived: z14.literal(true).parse(record.archived) };
+      output = { archived: z16.literal(true).parse(record.archived) };
     else if (route === "monitoring prepare")
-      output = { state: z14.literal("prepared").parse(record.state) };
+      output = { state: z16.literal("prepared").parse(record.state) };
     else if (action === "realtime") output = pick(record, liveKeys);
     else {
       const resource = Resource.parse(record.resource);
@@ -8739,8 +9034,8 @@ async function runAnalyticsCommand(options) {
         output = {
           resource,
           lastReceivedAt: record.lastReceivedAt,
-          consentSource: z14.object({
-            consentSource: z14.enum([
+          consentSource: z16.object({
+            consentSource: z16.enum([
               "cookie",
               "external",
               "waiting_for_cookie",
@@ -8752,11 +9047,11 @@ async function runAnalyticsCommand(options) {
       else if (action === "installation")
         output = {
           resource,
-          installation: z14.string().parse(record.installation),
+          installation: z16.string().parse(record.installation),
           configuration: record.configuration
         };
       else if (action === "events") {
-        const definitions = z14.array(EventInput).parse(record.definitions);
+        const definitions = z16.array(EventInput).parse(record.definitions);
         if (route === "events snippet") {
           const definition = definitions.find((d) => d.name === positionals[2]);
           if (!definition)
@@ -8770,13 +9065,13 @@ async function runAnalyticsCommand(options) {
           };
         } else output = { definitions, eventCounts: record.eventCounts };
       } else
-        output = action === "report" ? pick(record, readKeys) : { [action]: z14.array(z14.unknown()).parse(record[action]) };
+        output = action === "report" ? pick(record, readKeys) : { [action]: z16.array(z16.unknown()).parse(record[action]) };
     }
     return { exitCode: 0, stdout: JSON.stringify(output, null, 2) };
   } catch (cause) {
     const error = cause instanceof SiteOSAuthApiError ? { code: cause.code, message: cause.message } : {
       code: "ANALYTICS_COMMAND_FAILED",
-      message: cause instanceof z14.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
+      message: cause instanceof z16.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -8786,13 +9081,13 @@ async function runAnalyticsCommand(options) {
 }
 
 // src/services/seo-repair-command.ts
-import { parseArgs as parseArgs5 } from "util";
-import { z as z16 } from "zod";
+import { parseArgs as parseArgs6 } from "util";
+import { z as z18 } from "zod";
 
 // src/services/seo-report-client.ts
 import { open, writeFile as writeFile8 } from "fs/promises";
-import path26 from "path";
-import { z as z15 } from "zod";
+import path27 from "path";
+import { z as z17 } from "zod";
 async function seoReportClient(options, environment) {
   const context = await commonServiceContext(options, "seo", environment);
   if (!context)
@@ -8827,8 +9122,8 @@ async function seoReportClient(options, environment) {
         }
       );
       if (!response.ok) {
-        const result = z15.object({
-          error: z15.object({ code: z15.string(), message: z15.string().max(500) })
+        const result = z17.object({
+          error: z17.object({ code: z17.string(), message: z17.string().max(500) })
         }).safeParse(await response.json());
         throw new SiteOSAuthApiError({
           code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -8842,12 +9137,12 @@ async function seoReportClient(options, environment) {
     }
   };
 }
-var versionedReport = z15.object({ contractVersion: z15.literal(1) }).passthrough();
+var versionedReport = z17.object({ contractVersion: z17.literal(1) }).passthrough();
 async function readSeoInput(cwd, filename) {
-  const file = await open(path26.resolve(cwd ?? process.cwd(), filename), "r");
+  const file = await open(path27.resolve(cwd ?? process.cwd(), filename), "r");
   try {
-    const stat3 = await file.stat();
-    if (!stat3.isFile() || stat3.size > 32e3)
+    const stat4 = await file.stat();
+    if (!stat4.isFile() || stat4.size > 32e3)
       throw new Error("Use a JSON request file of at most 32,000 bytes.");
     const buffer = Buffer.alloc(32001);
     let bytes = 0;
@@ -8868,14 +9163,14 @@ async function readSeoInput(cwd, filename) {
   }
 }
 async function writeSeoReport(options, filename, content) {
-  const output = path26.resolve(options.cwd ?? process.cwd(), filename);
+  const output = path27.resolve(options.cwd ?? process.cwd(), filename);
   await writeFile8(output, content, { flag: "wx", mode: 384 });
   return output;
 }
 function seoReportFailure(cause, json, idempotencyKey) {
   const error = {
     code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-    message: cause instanceof z15.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+    message: cause instanceof z17.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
   };
   return {
     exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -8894,7 +9189,7 @@ function seoReportFailure(cause, json, idempotencyKey) {
 async function runSeoRepairCommand(options) {
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs5({
+    const { positionals, values } = parseArgs6({
       args: options.args,
       allowPositionals: true,
       strict: true,
@@ -8939,32 +9234,32 @@ async function runSeoRepairCommand(options) {
     });
     const record = versionedReport.parse(await response.json());
     if (recheck) {
-      z16.object({
-        id: z16.string(),
-        resourceId: z16.literal(client.resourceId),
-        organizationId: z16.literal(client.organizationId),
-        state: z16.literal("queued")
+      z18.object({
+        id: z18.string(),
+        resourceId: z18.literal(client.resourceId),
+        organizationId: z18.literal(client.organizationId),
+        state: z18.literal("queued")
       }).parse(record.audit);
       return { exitCode: 0, stdout: JSON.stringify(record, null, 2) };
     }
-    const brief = z16.object({
-      schemaVersion: z16.literal(1),
-      context: z16.object({
-        auditId: z16.literal(values.audit),
-        resourceId: z16.literal(client.resourceId),
-        organizationId: z16.literal(client.organizationId),
-        selectedUrls: z16.array(z16.string()).min(1).max(20),
-        ruleId: z16.literal(values.rule ?? null)
+    const brief = z18.object({
+      schemaVersion: z18.literal(1),
+      context: z18.object({
+        auditId: z18.literal(values.audit),
+        resourceId: z18.literal(client.resourceId),
+        organizationId: z18.literal(client.organizationId),
+        selectedUrls: z18.array(z18.string()).min(1).max(20),
+        ruleId: z18.literal(values.rule ?? null)
       }),
-      evidence: z16.array(
-        z16.object({
-          url: z16.string(),
-          findings: z16.array(z16.unknown()).max(12)
+      evidence: z18.array(
+        z18.object({
+          url: z18.string(),
+          findings: z18.array(z18.unknown()).max(12)
         })
       ).min(1).max(20),
-      suggestedGroups: z16.array(z16.unknown()),
-      verificationCommand: z16.string().min(1),
-      text: z16.string().min(1)
+      suggestedGroups: z18.array(z18.unknown()),
+      verificationCommand: z18.string().min(1),
+      text: z18.string().min(1)
     }).parse(record);
     const canonical = (value) => {
       const url = new URL(value);
@@ -8985,15 +9280,15 @@ async function runSeoRepairCommand(options) {
 
 // src/services/seo-command.ts
 import { writeFile as writeFile10 } from "fs/promises";
-import path28 from "path";
-import { parseArgs as parseArgs9 } from "util";
-import { z as z20 } from "zod";
+import path29 from "path";
+import { parseArgs as parseArgs10 } from "util";
+import { z as z22 } from "zod";
 
 // src/services/seo-research-command.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { setTimeout as setTimeout2 } from "timers/promises";
-import { isDeepStrictEqual, parseArgs as parseArgs6 } from "util";
-import { z as z17 } from "zod";
+import { isDeepStrictEqual, parseArgs as parseArgs7 } from "util";
+import { z as z19 } from "zod";
 var RESEARCH_HELP = `
   siteos seo research summary [--environment <slug>] [--json]
   siteos seo research status --kind <kind> [--environment <slug>] [--json]
@@ -9015,15 +9310,15 @@ var RESEARCH_HELP = `
 
 Research request kinds: keywords, domain, rankings, backlinks, brand, ai-visibility.
 Read sections also accept --kind ai-rankings for category comparisons; --kind ai-visibility selects Prompt checks.
-Category run/plan inputs use kind ai-visibility with category-aeo-v2; both sections share AI request execution.
+Category run/plan inputs use kind ai-visibility with category-mentions-v3; both sections share AI request execution.
 Domain Overview: {"kind":"domain","target":"example.com","country":"US","language":"en"}.
 Domain collects summary, ranking keywords, top pages and competitors. The legacy competitors kind retains its two-part plan; domain history includes those reports.
 Request JSON: {"kind":"keywords","target":"example.com","keywords":["website analytics"],"country":"US","language":"en"}.
-Rankings accepts up to 10 keywords and 5 competitors. AI visibility accepts brand, platforms and either prompt or a category-aeo-v2 category with products and questions.
+Rankings accepts up to 10 keywords and 5 competitors. AI visibility accepts brand, platforms and either prompt or a category-mentions-v3 category with products and questions.
 Markets: US, GB, ES, DE, FR, CA, AU. Languages: en, es, de, fr, pt, it, nl, ru.
 Platforms: chat_gpt, claude, gemini, perplexity. Brand lookup uses brandPlatform chat_gpt|google and brandMatch domain|brand.
 Plan validates the request and shows planned parts and available research credits without enqueueing work.
-Retry creates a continuation using the original questions and settings; it preserves usable saved answers and only requests missing parts. It consumes credits and requires explicit scope authorization, like Run. Original reports and observation dates remain available.
+Retry creates a continuation using the original questions and platforms; category continuations collect ordinary text with category-mentions-v3; it preserves usable saved answers and only requests missing parts. It consumes credits and requires explicit scope authorization, like Run. Original reports and observation dates remain available.
 Run consumes Organization research credits through the same worker as the interface. Preserve the retry key after an uncertain response.
 SERP ensure collects one saved organic snapshot for a keyword returned by the selected completed Keyword Research report. It uses research credits once; repeating the same report/word returns the saved job, including failures. Show/wait/export only read and never spend. New reports can collect fresh snapshots.
 History returns the latest 30 checks per section; show/export can address older retained run IDs. Saved checks are limited to 100 per resource.
@@ -9040,11 +9335,11 @@ var kinds = [
 ];
 var sections = [...kinds, "ai-rankings"];
 var sectionOf = (request) => request.kind === "ai-visibility" && request.category ? "ai-rankings" : request.kind;
-var requestSchema = z17.object({
-  kind: z17.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
-  target: z17.string().min(1).max(253)
+var requestSchema = z19.object({
+  kind: z19.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
+  target: z19.string().min(1).max(253)
 }).passthrough();
-var runStates = z17.enum([
+var runStates = z19.enum([
   "queued",
   "running",
   "completed",
@@ -9060,7 +9355,7 @@ var csvCell = (value) => {
 async function runSeoResearchCommand(options) {
   let idempotencyKey;
   try {
-    const { values, positionals } = parseArgs6({
+    const { values, positionals } = parseArgs7({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9142,26 +9437,26 @@ async function runSeoResearchCommand(options) {
         );
     }
     const client = await seoReportClient(options, values.environment);
-    const resourceSchema = z17.object({
-      id: z17.literal(client.resourceId),
-      organizationId: z17.literal(client.organizationId)
+    const resourceSchema = z19.object({
+      id: z19.literal(client.resourceId),
+      organizationId: z19.literal(client.organizationId)
     }).passthrough();
-    const runSchema = z17.object({
-      id: z17.string(),
-      resourceId: z17.literal(client.resourceId),
-      organizationId: z17.literal(client.organizationId),
-      websiteUrl: z17.string(),
+    const runSchema = z19.object({
+      id: z19.string(),
+      resourceId: z19.literal(client.resourceId),
+      organizationId: z19.literal(client.organizationId),
+      websiteUrl: z19.string(),
       request: requestSchema,
       state: runStates,
-      createdAt: z17.string(),
-      finishedAt: z17.string().nullable(),
-      parts: z17.array(
-        z17.object({
-          key: z17.string(),
-          state: z17.enum(["completed", "failed"]),
-          error: z17.string().nullable(),
-          dataset: z17.record(z17.unknown()).nullable(),
-          observedAt: z17.string()
+      createdAt: z19.string(),
+      finishedAt: z19.string().nullable(),
+      parts: z19.array(
+        z19.object({
+          key: z19.string(),
+          state: z19.enum(["completed", "failed"]),
+          error: z19.string().nullable(),
+          dataset: z19.record(z19.unknown()).nullable(),
+          observedAt: z19.string()
         }).passthrough()
       )
     }).passthrough();
@@ -9175,36 +9470,36 @@ async function runSeoResearchCommand(options) {
     const query = `?kind=${encodeURIComponent(values.kind ?? "rankings")}`;
     let record;
     if (action.startsWith("serp ")) {
-      const snapshotSchema = z17.object({
-        id: z17.string(),
-        organizationId: z17.literal(client.organizationId),
-        resourceId: z17.literal(client.resourceId),
-        sourceRunId: z17.literal(id),
+      const snapshotSchema = z19.object({
+        id: z19.string(),
+        organizationId: z19.literal(client.organizationId),
+        resourceId: z19.literal(client.resourceId),
+        sourceRunId: z19.literal(id),
         request: requestSchema,
-        keywordKey: z17.literal(
+        keywordKey: z19.literal(
           values.keyword.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ")
         ),
-        state: z17.enum([
+        state: z19.enum([
           "queued",
           "running",
           "completed",
           "failed",
           "cancelled"
         ]),
-        dataset: z17.object({
-          type: z17.literal("serp"),
-          keyword: z17.string(),
-          country: z17.string(),
-          language: z17.string(),
-          device: z17.enum(["desktop", "mobile"]),
-          observedAt: z17.string(),
-          rows: z17.array(
-            z17.object({
-              position: z17.number(),
-              title: z17.string(),
-              url: z17.string(),
-              domain: z17.string(),
-              description: z17.string()
+        dataset: z19.object({
+          type: z19.literal("serp"),
+          keyword: z19.string(),
+          country: z19.string(),
+          language: z19.string(),
+          device: z19.enum(["desktop", "mobile"]),
+          observedAt: z19.string(),
+          rows: z19.array(
+            z19.object({
+              position: z19.number(),
+              title: z19.string(),
+              url: z19.string(),
+              domain: z19.string(),
+              description: z19.string()
             })
           )
         }).nullable()
@@ -9314,9 +9609,9 @@ async function runSeoResearchCommand(options) {
           name: values.name.trim(),
           ...values.id ? { id: values.id } : {}
         });
-        const saved = z17.object({
-          id: z17.string(),
-          name: z17.literal(values.name.trim()),
+        const saved = z19.object({
+          id: z19.string(),
+          name: z19.literal(values.name.trim()),
           request: requestSchema
         }).parse(record.saved);
         if (values.id && saved.id !== values.id || !isDeepStrictEqual(saved.request, plan.request))
@@ -9330,23 +9625,23 @@ async function runSeoResearchCommand(options) {
         action === "cancel" ? "run" : "write",
         {}
       );
-      z17.literal(true).parse(
+      z19.literal(true).parse(
         record[action === "cancel" ? "cancelled" : "removed"]
       );
     } else if (action === "summary") {
       record = await get("/summary");
       resourceSchema.parse(record.resource);
-      z17.array(z17.object({ kind: z17.enum(sections), summary: z17.unknown() })).parse(
+      z19.array(z19.object({ kind: z19.enum(sections), summary: z19.unknown() })).parse(
         record.checks
       );
     } else if (["status", "history", "saved list"].includes(action)) {
       const view = await get(query);
       resourceSchema.parse(view.resource);
-      const runs = z17.array(runSchema).parse(view.runs);
-      const saved = z17.array(
-        z17.object({
-          id: z17.string(),
-          name: z17.string(),
+      const runs = z19.array(runSchema).parse(view.runs);
+      const saved = z19.array(
+        z19.object({
+          id: z19.string(),
+          name: z19.string(),
           request: requestSchema
         }).passthrough()
       ).parse(view.saved);
@@ -9481,8 +9776,8 @@ async function runSeoResearchCommand(options) {
 }
 
 // src/services/seo-gsc-command.ts
-import { parseArgs as parseArgs7 } from "util";
-import { z as z18 } from "zod";
+import { parseArgs as parseArgs8 } from "util";
+import { z as z20 } from "zod";
 var GSC_HELP = `
   siteos seo gsc status [--environment <slug>] [--json]
   siteos seo gsc report [--dataset <pages|queries>] [--query <text>] [--filter <all|issues|declining>] [--sort <clicks|change|impressions>] [--page <number>] [--url <page-url>] [--environment <slug>] [--json]
@@ -9500,7 +9795,7 @@ Bind/disconnect require a current revision and separate settings authority. Disc
 `;
 async function runSeoGscCommand(options) {
   try {
-    const { values, positionals } = parseArgs7({
+    const { values, positionals } = parseArgs8({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9582,13 +9877,13 @@ async function runSeoGscCommand(options) {
       `seo:search:${action === "sync" ? "sync" : writing ? "write" : "read"}`,
       body
     );
-    const runSchema = z18.object({
-      id: z18.string(),
-      resourceId: z18.literal(client.resourceId),
-      organizationId: z18.literal(client.organizationId),
-      websiteUrl: z18.string(),
-      siteUrl: z18.string(),
-      state: z18.enum([
+    const runSchema = z20.object({
+      id: z20.string(),
+      resourceId: z20.literal(client.resourceId),
+      organizationId: z20.literal(client.organizationId),
+      websiteUrl: z20.string(),
+      siteUrl: z20.string(),
+      state: z20.enum([
         "queued",
         "running",
         "completed",
@@ -9596,32 +9891,32 @@ async function runSeoGscCommand(options) {
         "failed",
         "cancelled"
       ]),
-      dates: z18.unknown()
+      dates: z20.unknown()
     }).passthrough();
-    const bindingSchema = z18.object({
-      resourceId: z18.literal(client.resourceId),
-      organizationId: z18.literal(client.organizationId),
-      websiteUrl: z18.string(),
-      siteUrl: z18.string(),
-      revision: z18.number().int().positive()
+    const bindingSchema = z20.object({
+      resourceId: z20.literal(client.resourceId),
+      organizationId: z20.literal(client.organizationId),
+      websiteUrl: z20.string(),
+      siteUrl: z20.string(),
+      revision: z20.number().int().positive()
     }).passthrough();
-    const metrics = z18.object({
-      clicks: z18.number(),
-      impressions: z18.number(),
-      ctr: z18.number(),
-      position: z18.number()
+    const metrics = z20.object({
+      clicks: z20.number(),
+      impressions: z20.number(),
+      ctr: z20.number(),
+      position: z20.number()
     }).passthrough().nullable();
     const validateView = (data) => {
       const record2 = versionedReport.parse(data);
-      z18.literal(client.resourceId).parse(record2.resourceId);
+      z20.literal(client.resourceId).parse(record2.resourceId);
       bindingSchema.nullable().parse(record2.binding);
       runSchema.nullable().parse(record2.latest);
       runSchema.nullable().parse(record2.report);
-      z18.array(
-        z18.object({ key: z18.string(), current: metrics, previous: metrics }).passthrough()
+      z20.array(
+        z20.object({ key: z20.string(), current: metrics, previous: metrics }).passthrough()
       ).parse(record2.rows);
-      z18.number().int().nonnegative().parse(record2.total);
-      z18.literal(values.dataset ?? "pages").parse(record2.dataset);
+      z20.number().int().nonnegative().parse(record2.total);
+      z20.literal(values.dataset ?? "pages").parse(record2.dataset);
       return record2;
     };
     if (action === "export") {
@@ -9637,9 +9932,9 @@ async function runSeoGscCommand(options) {
       const text = await response.text();
       if (values.format === "json") {
         const report = validateView(JSON.parse(text));
-        z18.literal(reportId).parse(runSchema.parse(report.report).id);
-        z18.array(z18.unknown()).length(rows).parse(report.rows);
-        z18.literal(truncated === "true").parse(report.truncated);
+        z20.literal(reportId).parse(runSchema.parse(report.report).id);
+        z20.array(z20.unknown()).length(rows).parse(report.rows);
+        z20.literal(truncated === "true").parse(report.truncated);
       }
       const output = await writeSeoReport(options, values.output, text);
       return {
@@ -9660,7 +9955,7 @@ async function runSeoGscCommand(options) {
       };
     }
     const record = versionedReport.parse(await response.json());
-    if (action === "disconnect") z18.literal(true).parse(record.unbound);
+    if (action === "disconnect") z20.literal(true).parse(record.unbound);
     else if (writing) {
       runSchema.parse(record.run);
       if (action === "bind") {
@@ -9680,10 +9975,10 @@ async function runSeoGscCommand(options) {
 // src/services/seo-performance-command.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { writeFile as writeFile9 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { setTimeout as setTimeout3 } from "timers/promises";
-import { parseArgs as parseArgs8 } from "util";
-import { z as z19 } from "zod";
+import { parseArgs as parseArgs9 } from "util";
+import { z as z21 } from "zod";
 var PERFORMANCE_HELP = `
   siteos seo performance run --audit <id> --url <url> [--url <url>...] [--device <mobile|desktop>] [--idempotency-key <key>] [--environment <slug>] [--json]
   siteos seo performance list [--device <mobile|desktop>] [--environment <slug>] [--json]
@@ -9700,7 +9995,7 @@ Reuse the returned idempotency key after an uncertain run response. Wait default
 async function runSeoPerformanceCommand(options) {
   let idempotencyKey;
   try {
-    const { values, positionals } = parseArgs8({
+    const { values, positionals } = parseArgs9({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9771,12 +10066,12 @@ async function runSeoPerformanceCommand(options) {
     const runtime = commonProjectRuntime(options);
     const writing = ["run", "cancel"].includes(action);
     const scope = writing ? "seo:audits:write" : "seo:workspace:read";
-    const batchSchema = z19.object({
-      id: z19.string(),
-      resourceId: z19.literal(context.resourceId),
-      organizationId: z19.literal(context.overview.project.organizationId),
-      sourceAuditId: z19.string(),
-      state: z19.enum([
+    const batchSchema = z21.object({
+      id: z21.string(),
+      resourceId: z21.literal(context.resourceId),
+      organizationId: z21.literal(context.overview.project.organizationId),
+      sourceAuditId: z21.string(),
+      state: z21.enum([
         "queued",
         "running",
         "completed",
@@ -9784,8 +10079,8 @@ async function runSeoPerformanceCommand(options) {
         "failed",
         "cancelled"
       ]),
-      device: z19.enum(["mobile", "desktop"]),
-      urls: z19.array(z19.string()).min(1).max(10)
+      device: z21.enum(["mobile", "desktop"]),
+      urls: z21.array(z21.string()).min(1).max(10)
     }).passthrough();
     const query = new URLSearchParams();
     if (values.device) query.set("device", values.device);
@@ -9833,17 +10128,17 @@ async function runSeoPerformanceCommand(options) {
           );
         const text = await response.text();
         if (values.format === "json") {
-          const parsed = z19.object({
-            contractVersion: z19.literal(1),
+          const parsed = z21.object({
+            contractVersion: z21.literal(1),
             batch: batchSchema,
-            pages: z19.array(z19.unknown())
+            pages: z21.array(z21.unknown())
           }).parse(JSON.parse(text));
           if (parsed.batch.id !== id)
             throw new Error(
               "The export response does not match the selected check."
             );
         }
-        const output = path27.resolve(
+        const output = path28.resolve(
           options.cwd ?? process.cwd(),
           values.output
         );
@@ -9859,8 +10154,8 @@ async function runSeoPerformanceCommand(options) {
       }
       const data = await response.json();
       if (!response.ok) {
-        const error = z19.object({
-          error: z19.object({ code: z19.string(), message: z19.string().max(500) })
+        const error = z21.object({
+          error: z21.object({ code: z21.string(), message: z21.string().max(500) })
         }).safeParse(data);
         throw new SiteOSAuthApiError({
           code: error.success ? error.data.error.code : "SEO_REQUEST_FAILED",
@@ -9868,8 +10163,8 @@ async function runSeoPerformanceCommand(options) {
           status: response.status
         });
       }
-      const record = z19.object({ contractVersion: z19.literal(1) }).passthrough().parse(data);
-      if (action === "cancel") z19.literal(true).parse(record.cancelled);
+      const record = z21.object({ contractVersion: z21.literal(1) }).passthrough().parse(data);
+      if (action === "cancel") z21.literal(true).parse(record.cancelled);
       else if (action === "run") {
         const accepted = batchSchema.parse(record.batch);
         const normalize = (url) => {
@@ -9882,8 +10177,8 @@ async function runSeoPerformanceCommand(options) {
             "The queued check does not match the requested source, device and URLs."
           );
       } else {
-        z19.literal(context.resourceId).parse(record.resourceId);
-        z19.array(batchSchema).parse(record.batches);
+        z21.literal(context.resourceId).parse(record.resourceId);
+        z21.array(batchSchema).parse(record.batches);
         const selected = batchSchema.nullable().parse(record.batch);
         if (id && selected?.id !== id)
           throw new Error(
@@ -9910,7 +10205,7 @@ async function runSeoPerformanceCommand(options) {
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z19.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
+      message: cause instanceof z21.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -9982,7 +10277,7 @@ async function runSeoCommand(options) {
     return runSeoRepairCommand(options);
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs9({
+    const { positionals, values } = parseArgs10({
       args: options.args,
       strict: true,
       allowPositionals: true,
@@ -10188,17 +10483,17 @@ async function runSeoCommand(options) {
         );
       const text = await response.text();
       if (values.format === "json")
-        z20.object({
-          contractVersion: z20.literal(1),
-          audit: z20.object({
-            id: z20.literal(values.audit),
-            resourceId: z20.literal(context.resourceId)
+        z22.object({
+          contractVersion: z22.literal(1),
+          audit: z22.object({
+            id: z22.literal(values.audit),
+            resourceId: z22.literal(context.resourceId)
           }),
-          kind: z20.literal(values.kind),
-          totalRows: z20.literal(rows),
-          rows: z20.array(z20.unknown()).length(rows)
+          kind: z22.literal(values.kind),
+          totalRows: z22.literal(rows),
+          rows: z22.array(z22.unknown()).length(rows)
         }).parse(JSON.parse(text));
-      const output = path28.resolve(options.cwd ?? process.cwd(), values.output);
+      const output = path29.resolve(options.cwd ?? process.cwd(), values.output);
       await writeFile10(output, text, { flag: "wx", mode: 384 });
       return {
         exitCode: 0,
@@ -10217,8 +10512,8 @@ async function runSeoCommand(options) {
     }
     const data = await response.json();
     if (!response.ok) {
-      const result = z20.object({
-        error: z20.object({ code: z20.string(), message: z20.string().max(500) })
+      const result = z22.object({
+        error: z22.object({ code: z22.string(), message: z22.string().max(500) })
       }).safeParse(data);
       throw new SiteOSAuthApiError({
         code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -10226,34 +10521,34 @@ async function runSeoCommand(options) {
         status: response.status
       });
     }
-    const record = z20.object({ contractVersion: z20.literal(1) }).passthrough().parse(data);
+    const record = z22.object({ contractVersion: z22.literal(1) }).passthrough().parse(data);
     if (automation) {
-      z20.literal(context.resourceId).parse(record.resourceId);
-      const schedule = z20.object({
-        enabled: z20.boolean(),
-        weekday: z20.number().int().min(1).max(7),
-        time: z20.string(),
-        timeZone: z20.string(),
-        revision: z20.number().int().min(0),
-        nextRunAt: z20.string().nullable()
+      z22.literal(context.resourceId).parse(record.resourceId);
+      const schedule = z22.object({
+        enabled: z22.boolean(),
+        weekday: z22.number().int().min(1).max(7),
+        time: z22.string(),
+        timeZone: z22.string(),
+        revision: z22.number().int().min(0),
+        nextRunAt: z22.string().nullable()
       });
-      const notificationRoute = z20.object({
-        enabled: z20.boolean(),
-        minimumSeverity: z20.enum(["error", "warning"]),
-        includeFailures: z20.boolean(),
-        revision: z20.number().int().min(0),
-        destinationId: z20.string().nullable()
+      const notificationRoute = z22.object({
+        enabled: z22.boolean(),
+        minimumSeverity: z22.enum(["error", "warning"]),
+        includeFailures: z22.boolean(),
+        revision: z22.number().int().min(0),
+        destinationId: z22.string().nullable()
       });
       if (retryNotification) {
-        z20.literal(true).parse(record.retryQueued);
-        z20.literal(positionals[2]).parse(record.notificationId);
+        z22.literal(true).parse(record.retryQueued);
+        z22.literal(positionals[2]).parse(record.notificationId);
       } else if (route === "notifications destinations")
-        z20.object({
-          candidates: z20.array(
-            z20.object({
-              candidateId: z20.string(),
-              label: z20.string(),
-              availability: z20.literal("available")
+        z22.object({
+          candidates: z22.array(
+            z22.object({
+              candidateId: z22.string(),
+              label: z22.string(),
+              availability: z22.literal("available")
             })
           )
         }).parse(record);
@@ -10266,46 +10561,46 @@ async function runSeoCommand(options) {
         notificationRoute.parse(record.route);
       }
     } else if (!writing) {
-      const validated = z20.object({
-        resource: z20.object({
-          id: z20.literal(context.resourceId),
-          organizationId: z20.literal(context.overview.project.organizationId)
+      const validated = z22.object({
+        resource: z22.object({
+          id: z22.literal(context.resourceId),
+          organizationId: z22.literal(context.overview.project.organizationId)
         }),
-        audits: z20.array(z20.object({ id: z20.string() }).passthrough()),
-        audit: z20.object({
-          id: z20.string(),
-          resourceId: z20.literal(context.resourceId)
+        audits: z22.array(z22.object({ id: z22.string() }).passthrough()),
+        audit: z22.object({
+          id: z22.string(),
+          resourceId: z22.literal(context.resourceId)
         }).passthrough().nullable(),
-        pages: z20.array(z20.unknown()),
-        issues: z20.array(z20.unknown()),
-        changes: z20.array(z20.unknown()),
-        totalChanges: z20.number(),
-        dispositions: z20.array(z20.unknown())
+        pages: z22.array(z22.unknown()),
+        issues: z22.array(z22.unknown()),
+        changes: z22.array(z22.unknown()),
+        totalChanges: z22.number(),
+        dispositions: z22.array(z22.unknown())
       }).passthrough().parse(record);
       const selected = query.get("audit");
       if (selected && validated.audit?.id !== selected)
         throw new Error("The SEO response does not match the requested audit.");
     } else if (record.audit)
-      z20.object({
-        id: z20.string(),
-        resourceId: z20.literal(context.resourceId),
-        organizationId: z20.literal(context.overview.project.organizationId),
-        state: z20.literal("queued")
+      z22.object({
+        id: z22.string(),
+        resourceId: z22.literal(context.resourceId),
+        organizationId: z22.literal(context.overview.project.organizationId),
+        state: z22.literal("queued")
       }).parse(record.audit);
-    else if (route === "audit cancel") z20.literal(true).parse(record.cancelled);
+    else if (route === "audit cancel") z22.literal(true).parse(record.cancelled);
     else if (action === "issue")
-      z20.object({
-        url: z20.literal(values.url),
-        ruleId: z20.literal(values.rule),
-        ignored: z20.literal(positionals[1] === "ignore"),
-        revision: z20.literal(Number(values.revision) + 1)
+      z22.object({
+        url: z22.literal(values.url),
+        ruleId: z22.literal(values.rule),
+        ignored: z22.literal(positionals[1] === "ignore"),
+        revision: z22.literal(Number(values.revision) + 1)
       }).parse(record.disposition);
     else throw new Error("The SEO service returned an invalid response.");
     return { exitCode: 0, stdout: JSON.stringify(record, null, 2) };
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z20.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+      message: cause instanceof z22.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,