@canonry/canonry 4.170.0 → 4.171.0

package/dist/cli.js

@@ -26,11 +26,11 @@ import {
   showFirstRunNotice,
   trackCliCommandFinished,
   trackEvent
-} from "./chunk-NMCLLN5X.js";
+} from "./chunk-5KGN224W.js";
 import {
   autoSyncSkills,
   formatAutoSyncNotice
-} from "./chunk-HTUI6BSK.js";
+} from "./chunk-RR4KSDOD.js";
 import {
   CliError,
   EXIT_SYSTEM_ERROR,
@@ -55,7 +55,7 @@ import {
   saveConfigPatch,
   systemError,
   usageError
-} from "./chunk-BMW3AURU.js";
+} from "./chunk-IIFDS3K2.js";
 import {
   CLOUDFLARE_WORKER_BINDINGS,
   CLOUDFLARE_WORKER_GENERATED_MARKER,
@@ -69,7 +69,7 @@ import {
   projects,
   queries,
   renderReportHtml
-} from "./chunk-CCZNCH7Y.js";
+} from "./chunk-O226BLC7.js";
 import {
   AdsDeliverySnapshotStatuses,
   AdsHistoricalCampaignRollupStatuses,
@@ -104,6 +104,9 @@ import {
   adsPauseRequestSchema,
   backlinkSourceSchema,
   buildModelChangeNotice,
+  canonicalizeGtmAccountId,
+  canonicalizeGtmResourceSelection,
+  conversionTrackingContractWriteRequestSchema,
   describeError,
   discoveryBucketSchema,
   discoveryCompetitorTypeSchema,
@@ -3880,9 +3883,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs19 = await import("fs");
+    const fs20 = await import("fs");
     try {
-      const content = fs19.readFileSync(opts.keyFile, "utf-8");
+      const content = fs20.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -5233,6 +5236,581 @@ var GBP_CLI_COMMANDS = [
   }
 ];
 
+// src/commands/google-marketing.ts
+import fs4 from "fs";
+function printMachine(value, format) {
+  if (!isMachineFormat(format)) return false;
+  console.log(JSON.stringify(value, null, 2));
+  return true;
+}
+function connectionSummary(status) {
+  if (!status.connected) return "not connected";
+  if (status.status === "selection-required") return "connected; selection required";
+  return status.status === "stale" ? "connected; stored evidence is stale" : "connected";
+}
+function snapshotSummary(snapshot) {
+  return `${snapshot.capturedAt}  ${snapshot.kind.padEnd(22)}  ${snapshot.id}  ${snapshot.payloadChecksum.slice(0, 12)}`;
+}
+function canonicalGtmReadAccountId(accountId) {
+  const canonical = canonicalizeGtmAccountId(accountId);
+  if (canonical) return canonical;
+  throw new CliError({
+    code: "GTM_RESOURCE_INPUT_INVALID",
+    message: "GTM account must be a safe bare ID or an accounts/{id} resource path.",
+    displayMessage: "Error: GTM account must be a safe bare ID or an accounts/{id} resource path."
+  });
+}
+function canonicalGtmReadSelection(accountId, containerId) {
+  const canonical = canonicalizeGtmResourceSelection({ accountId, containerId });
+  if (canonical) return canonical;
+  throw new CliError({
+    code: "GTM_RESOURCE_INPUT_INVALID",
+    message: "GTM account and container must be matching safe IDs or resource paths.",
+    displayMessage: "Error: GTM account and container must be matching safe IDs or resource paths."
+  });
+}
+function readConversionTrackingContractInput(inputPath) {
+  if (!inputPath) {
+    throw new CliError({
+      code: "CONVERSION_TRACKING_INPUT_REQUIRED",
+      message: "A conversion-tracking contract JSON input file is required",
+      displayMessage: "Error: --input <json-file> is required (use --input - for stdin)"
+    });
+  }
+  try {
+    const raw = fs4.readFileSync(inputPath === "-" ? 0 : inputPath, "utf8");
+    return conversionTrackingContractWriteRequestSchema.parse(JSON.parse(raw));
+  } catch (err) {
+    const message = describeError(err);
+    throw new CliError({
+      code: "CONVERSION_TRACKING_INPUT_INVALID",
+      message,
+      displayMessage: `Error: invalid conversion-tracking contract input (${message})`,
+      details: { inputPath }
+    });
+  }
+}
+async function googleAdsDisconnect(client, project, opts) {
+  const result = await client.disconnectGoogleAds(project);
+  if (printMachine(result, opts.format)) return;
+  console.log(result.disconnected ? `Disconnected Google Ads from project "${project}". Stored redacted evidence was retained.` : `Google Ads was not connected to project "${project}".`);
+}
+async function gtmDisconnect(client, project, opts) {
+  const result = await client.disconnectGtm(project);
+  if (printMachine(result, opts.format)) return;
+  console.log(result.disconnected ? `Disconnected Google Tag Manager from project "${project}". Stored redacted evidence was retained.` : `Google Tag Manager was not connected to project "${project}".`);
+}
+async function googleAdsStatus(client, project, opts) {
+  const result = await client.getGoogleAdsStatus(project);
+  if (printMachine(result, opts.format)) return;
+  console.log(`Google Ads: ${connectionSummary(result)}`);
+  if (!result.connected) {
+    console.log(`Open project "${project}" in the Canonry dashboard to authorize Google Ads.`);
+    return;
+  }
+  const selection = result.connection.selection;
+  console.log(`Customer: ${selection.customerId ?? "not selected"}`);
+  if (selection.loginCustomerId) console.log(`Login customer: ${selection.loginCustomerId}`);
+  if (result.selectedCustomer) {
+    console.log(`Selected: ${result.selectedCustomer.descriptiveName ?? result.selectedCustomer.customerId} (${result.selectedCustomer.status})`);
+  }
+  console.log(`Last inventory snapshot: ${result.connection.lastInventorySnapshotAt ?? "none"}`);
+  console.log(`Last metrics snapshot: ${result.connection.lastMetricsSnapshotAt ?? "none"}`);
+}
+async function gtmStatus(client, project, opts) {
+  const result = await client.getGtmStatus(project);
+  if (printMachine(result, opts.format)) return;
+  console.log(`Google Tag Manager: ${connectionSummary(result)}`);
+  if (!result.connected) {
+    console.log(`Open project "${project}" in the Canonry dashboard to authorize Google Tag Manager.`);
+    return;
+  }
+  console.log(`Account: ${result.selection.accountId ?? "not selected"}`);
+  console.log(`Container: ${result.selection.containerId ?? "not selected"}`);
+  console.log(`Workspace: ${result.selection.workspaceId ?? "none (live only)"}`);
+  console.log(`Last snapshot: ${result.connection.lastSnapshotAt ?? "none"}`);
+}
+async function googleAdsCustomers(client, project, opts) {
+  const result = await client.listGoogleAdsCustomers(project);
+  if (opts.format === "jsonl") {
+    emitJsonl(result.customers.map((customer) => ({ project, fetchedAt: result.fetchedAt, ...customer })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  if (result.customers.length === 0) {
+    console.log("No Google Ads customers are visible to this OAuth connection.");
+    return;
+  }
+  console.log(`${result.totalAccessible} accessible customer(s)${result.truncated ? " (bounded list; truncated)" : ""}:
+`);
+  for (const customer of result.customers) {
+    const role = customer.manager ? "manager" : "client";
+    const name = customer.descriptiveName ?? "(unnamed)";
+    console.log(`  ${customer.customerId.padEnd(16)} ${name}  ${role}, ${customer.status}`);
+  }
+  console.log(`
+Select one with: canonry google-ads select ${project} --customer <customer-id>`);
+}
+async function googleAdsSelect(client, project, request, opts) {
+  const result = await client.setGoogleAdsSelection(project, request);
+  if (printMachine(result, opts.format)) return;
+  console.log(`Selected Google Ads customer ${request.customerId}${request.loginCustomerId ? ` through login customer ${request.loginCustomerId}` : ""}.`);
+  console.log(`Run \`canonry google-ads sync ${project}\` to capture read-only conversion and goal evidence.`);
+}
+async function googleAdsSync(client, project, opts) {
+  const run = await client.triggerGoogleAdsSync(project);
+  if (printMachine(run, opts.format)) return;
+  console.log(`Google Ads read-only sync queued (run ${run.id}). Use \`canonry run show ${run.id}\` to check it.`);
+}
+async function googleAdsSnapshots(client, project, opts) {
+  const result = await client.listGoogleAdsSnapshots(project, { limit: opts.limit, cursor: opts.cursor });
+  if (opts.format === "jsonl") {
+    emitJsonl(result.snapshots.map((snapshot) => ({ project, ...snapshot })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  if (result.snapshots.length === 0) {
+    console.log(`No stored Google Ads snapshots. Run \`canonry google-ads sync ${project}\` after selecting a customer.`);
+    return;
+  }
+  console.log(`${result.total} stored Google Ads snapshot(s):
+`);
+  for (const snapshot of result.snapshots) console.log(`  ${snapshotSummary(snapshot)}`);
+  if (result.nextCursor) console.log(`
+Next cursor: ${result.nextCursor}`);
+}
+async function googleAdsSnapshot(client, project, snapshotId, opts) {
+  const result = await client.getGoogleAdsSnapshot(project, snapshotId);
+  if (printMachine(result, opts.format)) return;
+  const { metadata, payload } = result.snapshot;
+  console.log(`Google Ads ${metadata.kind} snapshot ${metadata.id}`);
+  console.log(`Captured: ${metadata.capturedAt}`);
+  console.log(`Checksum: ${metadata.payloadChecksum}`);
+  console.log(`Payload kind: ${payload.kind}`);
+}
+async function gtmAccounts(client, project, opts) {
+  const result = await client.listGtmAccounts(project);
+  if (opts.format === "jsonl") {
+    emitJsonl(result.accounts.map((account) => ({ project, fetchedAt: result.fetchedAt, ...account })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  if (result.accounts.length === 0) {
+    console.log("No GTM accounts are visible to this OAuth connection.");
+    return;
+  }
+  console.log(`${result.totalAccessible} accessible GTM account(s)${result.truncated ? " (bounded list; truncated)" : ""}:
+`);
+  for (const account of result.accounts) console.log(`  ${account.id.padEnd(16)} ${account.name}`);
+  console.log(`
+Discover containers with: canonry gtm containers ${project} --account <account-id>`);
+}
+async function gtmContainers(client, project, accountId, opts) {
+  const canonicalAccountId = canonicalGtmReadAccountId(accountId);
+  const result = await client.listGtmContainers(project, canonicalAccountId);
+  if (opts.format === "jsonl") {
+    emitJsonl(result.containers.map((container) => ({ project, fetchedAt: result.fetchedAt, ...container })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  if (result.containers.length === 0) {
+    console.log(`No GTM containers are visible under account ${accountId}.`);
+    return;
+  }
+  console.log(`${result.totalAccessible} GTM container(s)${result.truncated ? " (bounded list; truncated)" : ""}:
+`);
+  for (const container of result.containers) {
+    const publicId = container.publicId ? ` (${container.publicId})` : "";
+    console.log(`  ${container.id.padEnd(16)} ${container.name}${publicId}`);
+  }
+  console.log(`
+Discover workspaces with: canonry gtm workspaces ${project} --account ${accountId} --container <container-id>`);
+}
+async function gtmWorkspaces(client, project, accountId, containerId, opts) {
+  const selection = canonicalGtmReadSelection(accountId, containerId);
+  const result = await client.listGtmWorkspaces(project, selection.accountId, selection.containerId);
+  if (opts.format === "jsonl") {
+    emitJsonl(result.workspaces.map((workspace) => ({ project, fetchedAt: result.fetchedAt, ...workspace })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  if (result.workspaces.length === 0) {
+    console.log(`No GTM workspaces are visible for container ${containerId}. A sync can still capture the live container graph.`);
+    return;
+  }
+  console.log(`${result.totalAccessible} GTM workspace(s)${result.truncated ? " (bounded list; truncated)" : ""}:
+`);
+  for (const workspace of result.workspaces) console.log(`  ${workspace.id.padEnd(16)} ${workspace.name}`);
+}
+async function gtmSelect(client, project, request, opts) {
+  const result = await client.setGtmSelection(project, request);
+  if (printMachine(result, opts.format)) return;
+  console.log(`Selected GTM account ${request.accountId}, container ${request.containerId}${request.workspaceId ? `, and workspace ${request.workspaceId}` : ""}.`);
+  console.log(`Run \`canonry gtm sync ${project}\` to capture redacted live${request.workspaceId ? " and draft" : ""} evidence.`);
+}
+async function gtmSync(client, project, opts) {
+  const run = await client.triggerGtmSync(project);
+  if (printMachine(run, opts.format)) return;
+  console.log(`GTM read-only sync queued (run ${run.id}). Use \`canonry run show ${run.id}\` to check it.`);
+}
+async function gtmSnapshots(client, project, opts) {
+  const result = await client.listGtmSnapshots(project, { limit: opts.limit, cursor: opts.cursor });
+  if (opts.format === "jsonl") {
+    emitJsonl(result.snapshots.map((snapshot) => ({ project, ...snapshot })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  if (result.snapshots.length === 0) {
+    console.log(`No stored GTM snapshots. Run \`canonry gtm sync ${project}\` after selecting a container.`);
+    return;
+  }
+  console.log(`${result.total} stored GTM snapshot(s):
+`);
+  for (const snapshot of result.snapshots) console.log(`  ${snapshotSummary(snapshot)}`);
+  if (result.nextCursor) console.log(`
+Next cursor: ${result.nextCursor}`);
+}
+async function gtmSnapshot(client, project, snapshotId, opts) {
+  const result = await client.getGtmSnapshot(project, snapshotId);
+  if (printMachine(result, opts.format)) return;
+  const { metadata, payload } = result.snapshot;
+  console.log(`GTM ${metadata.kind} snapshot ${metadata.id}`);
+  console.log(`Captured: ${metadata.capturedAt}`);
+  console.log(`Checksum: ${metadata.payloadChecksum}`);
+  console.log(`Payload kind: ${payload.kind}`);
+}
+async function conversionTrackingContracts(client, project, opts) {
+  const contracts = await client.listConversionTrackingContracts(project);
+  if (opts.format === "jsonl") {
+    emitJsonl(contracts.map((contract) => ({ project, ...contract })));
+    return;
+  }
+  if (printMachine(contracts, opts.format)) return;
+  if (contracts.length === 0) {
+    console.log("No conversion-tracking contracts are declared for this project.");
+    return;
+  }
+  console.log(`${contracts.length} conversion-tracking contract(s):
+`);
+  for (const contract of contracts) {
+    console.log(`  ${contract.id.padEnd(16)} ${contract.name}  event=${contract.eventName}`);
+  }
+}
+async function conversionTrackingContract(client, project, contractId, opts) {
+  const contract = await client.getConversionTrackingContract(project, contractId);
+  if (printMachine(contract, opts.format)) return;
+  printConversionTrackingContract(contract);
+}
+function printConversionTrackingContract(contract) {
+  console.log(`Conversion contract: ${contract.name} (${contract.id})`);
+  console.log(`Event: ${contract.eventName}`);
+  console.log(`Google Ads: customer ${contract.googleAds.customerId}, conversion action ${contract.googleAds.conversionActionId}`);
+  console.log(`GTM: account ${contract.gtm.accountId}, container ${contract.gtm.containerId}, tag ${contract.gtm.tagId}`);
+  console.log(`Runtime verification: ${contract.runtime.verificationRequired ? "required" : "not required"}`);
+}
+async function conversionTrackingCreate(client, project, request, opts) {
+  const contract = await client.createConversionTrackingContract(project, request);
+  if (printMachine(contract, opts.format)) return;
+  console.log(`Created conversion-tracking contract "${contract.name}" (${contract.id}).`);
+}
+async function conversionTrackingUpdate(client, project, contractId, request, opts) {
+  const contract = await client.updateConversionTrackingContract(project, contractId, request);
+  if (printMachine(contract, opts.format)) return;
+  console.log(`Updated conversion-tracking contract "${contract.name}" (${contract.id}).`);
+}
+async function conversionTrackingDelete(client, project, contractId, opts) {
+  await client.deleteConversionTrackingContract(project, contractId);
+  if (printMachine({ project, contractId, deleted: true }, opts.format)) return;
+  console.log(`Deleted conversion-tracking contract ${contractId}.`);
+}
+async function conversionTrackingIntegrity(client, project, contractId, opts) {
+  const result = await client.getConversionTrackingIntegrity(project, contractId);
+  if (opts.format === "jsonl") {
+    emitJsonl(result.assessment.findings.map((finding) => ({
+      project,
+      contractId: result.assessment.contract.id,
+      integrityStatus: result.assessment.status,
+      evaluatedAt: result.assessment.evaluatedAt,
+      ...finding
+    })));
+    return;
+  }
+  if (printMachine(result, opts.format)) return;
+  console.log(`Conversion integrity: ${result.assessment.contract.name} \u2014 ${result.assessment.status}`);
+  console.log(`Evaluated: ${result.assessment.evaluatedAt}`);
+  for (const finding of result.assessment.findings) {
+    console.log(`  ${finding.outcome.toUpperCase().padEnd(7)} ${finding.code} \u2014 ${finding.subject}`);
+  }
+  if (result.assessment.status === "runtime-unverified") {
+    console.log("\nStatic configuration is consistent, but a GTM API snapshot cannot prove that the website event fired or Google Ads observed a conversion.");
+  }
+}
+
+// src/cli-commands/google-marketing.ts
+function snapshotLimit(input, command, usage) {
+  const limit = parseIntegerOption(input, "limit", {
+    command,
+    usage,
+    message: "--limit must be an integer from 1 to 100"
+  });
+  if (limit !== void 0 && (limit < 1 || limit > 100)) {
+    throw usageError(`Error: --limit must be an integer from 1 to 100
+Usage: ${usage}`, {
+      message: "--limit must be an integer from 1 to 100",
+      details: { command, usage, option: "limit", value: limit }
+    });
+  }
+  return limit;
+}
+function createGoogleMarketingCliCommands(createClient2) {
+  return [
+    {
+      path: ["google-ads", "disconnect"],
+      usage: "canonry google-ads disconnect <project> [--format json]",
+      run: async (input) => {
+        const usage = "canonry google-ads disconnect <project> [--format json]";
+        await googleAdsDisconnect(createClient2(), requireProject(input, "google-ads.disconnect", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["google-ads", "status"],
+      usage: "canonry google-ads status <project> [--format json]",
+      run: async (input) => {
+        const usage = "canonry google-ads status <project> [--format json]";
+        await googleAdsStatus(createClient2(), requireProject(input, "google-ads.status", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["google-ads", "customers"],
+      usage: "canonry google-ads customers <project> [--format json|jsonl]",
+      run: async (input) => {
+        const usage = "canonry google-ads customers <project> [--format json|jsonl]";
+        await googleAdsCustomers(createClient2(), requireProject(input, "google-ads.customers", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["google-ads", "select"],
+      usage: "canonry google-ads select <project> --customer <customer-id> [--login-customer <manager-id>] [--format json]",
+      options: { customer: stringOption(), "login-customer": stringOption() },
+      run: async (input) => {
+        const usage = "canonry google-ads select <project> --customer <customer-id> [--login-customer <manager-id>] [--format json]";
+        const project = requireProject(input, "google-ads.select", usage);
+        const customerId = requireStringOption(input, "customer", {
+          command: "google-ads.select",
+          usage,
+          message: "--customer is required"
+        });
+        await googleAdsSelect(createClient2(), project, {
+          customerId,
+          ...getString(input.values, "login-customer") ? { loginCustomerId: getString(input.values, "login-customer") } : {}
+        }, { format: input.format });
+      }
+    },
+    {
+      path: ["google-ads", "sync"],
+      usage: "canonry google-ads sync <project> [--format json]",
+      run: async (input) => {
+        const usage = "canonry google-ads sync <project> [--format json]";
+        await googleAdsSync(createClient2(), requireProject(input, "google-ads.sync", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["google-ads", "snapshots"],
+      usage: "canonry google-ads snapshots <project> [--limit <n>] [--cursor <opaque>] [--format json|jsonl]",
+      options: { limit: stringOption(), cursor: stringOption() },
+      run: async (input) => {
+        const usage = "canonry google-ads snapshots <project> [--limit <n>] [--cursor <opaque>] [--format json|jsonl]";
+        await googleAdsSnapshots(createClient2(), requireProject(input, "google-ads.snapshots", usage), {
+          limit: snapshotLimit(input, "google-ads.snapshots", usage),
+          cursor: getString(input.values, "cursor"),
+          format: input.format
+        });
+      }
+    },
+    {
+      path: ["google-ads", "snapshot"],
+      usage: "canonry google-ads snapshot <project> <snapshot-id> [--format json]",
+      run: async (input) => {
+        const usage = "canonry google-ads snapshot <project> <snapshot-id> [--format json]";
+        const project = requireProject(input, "google-ads.snapshot", usage);
+        await googleAdsSnapshot(createClient2(), project, requirePositional(input, 1, {
+          command: "google-ads.snapshot",
+          usage,
+          message: "snapshot id is required"
+        }), { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "disconnect"],
+      usage: "canonry gtm disconnect <project> [--format json]",
+      run: async (input) => {
+        const usage = "canonry gtm disconnect <project> [--format json]";
+        await gtmDisconnect(createClient2(), requireProject(input, "gtm.disconnect", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "status"],
+      usage: "canonry gtm status <project> [--format json]",
+      run: async (input) => {
+        const usage = "canonry gtm status <project> [--format json]";
+        await gtmStatus(createClient2(), requireProject(input, "gtm.status", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "accounts"],
+      usage: "canonry gtm accounts <project> [--format json|jsonl]",
+      run: async (input) => {
+        const usage = "canonry gtm accounts <project> [--format json|jsonl]";
+        await gtmAccounts(createClient2(), requireProject(input, "gtm.accounts", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "containers"],
+      usage: "canonry gtm containers <project> --account <account-id> [--format json|jsonl]",
+      options: { account: stringOption() },
+      run: async (input) => {
+        const usage = "canonry gtm containers <project> --account <account-id> [--format json|jsonl]";
+        const project = requireProject(input, "gtm.containers", usage);
+        await gtmContainers(createClient2(), project, requireStringOption(input, "account", {
+          command: "gtm.containers",
+          usage,
+          message: "--account is required"
+        }), { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "workspaces"],
+      usage: "canonry gtm workspaces <project> --account <account-id> --container <container-id> [--format json|jsonl]",
+      options: { account: stringOption(), container: stringOption() },
+      run: async (input) => {
+        const usage = "canonry gtm workspaces <project> --account <account-id> --container <container-id> [--format json|jsonl]";
+        const project = requireProject(input, "gtm.workspaces", usage);
+        const accountId = requireStringOption(input, "account", { command: "gtm.workspaces", usage, message: "--account is required" });
+        const containerId = requireStringOption(input, "container", { command: "gtm.workspaces", usage, message: "--container is required" });
+        await gtmWorkspaces(createClient2(), project, accountId, containerId, { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "select"],
+      usage: "canonry gtm select <project> --account <account-id> --container <container-id> [--workspace <workspace-id>] [--format json]",
+      options: { account: stringOption(), container: stringOption(), workspace: stringOption() },
+      run: async (input) => {
+        const usage = "canonry gtm select <project> --account <account-id> --container <container-id> [--workspace <workspace-id>] [--format json]";
+        const project = requireProject(input, "gtm.select", usage);
+        const accountId = requireStringOption(input, "account", { command: "gtm.select", usage, message: "--account is required" });
+        const containerId = requireStringOption(input, "container", { command: "gtm.select", usage, message: "--container is required" });
+        const workspaceId = getString(input.values, "workspace");
+        await gtmSelect(createClient2(), project, {
+          accountId,
+          containerId,
+          ...workspaceId ? { workspaceId } : {}
+        }, { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "sync"],
+      usage: "canonry gtm sync <project> [--format json]",
+      run: async (input) => {
+        const usage = "canonry gtm sync <project> [--format json]";
+        await gtmSync(createClient2(), requireProject(input, "gtm.sync", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["gtm", "snapshots"],
+      usage: "canonry gtm snapshots <project> [--limit <n>] [--cursor <opaque>] [--format json|jsonl]",
+      options: { limit: stringOption(), cursor: stringOption() },
+      run: async (input) => {
+        const usage = "canonry gtm snapshots <project> [--limit <n>] [--cursor <opaque>] [--format json|jsonl]";
+        await gtmSnapshots(createClient2(), requireProject(input, "gtm.snapshots", usage), {
+          limit: snapshotLimit(input, "gtm.snapshots", usage),
+          cursor: getString(input.values, "cursor"),
+          format: input.format
+        });
+      }
+    },
+    {
+      path: ["gtm", "snapshot"],
+      usage: "canonry gtm snapshot <project> <snapshot-id> [--format json]",
+      run: async (input) => {
+        const usage = "canonry gtm snapshot <project> <snapshot-id> [--format json]";
+        const project = requireProject(input, "gtm.snapshot", usage);
+        await gtmSnapshot(createClient2(), project, requirePositional(input, 1, {
+          command: "gtm.snapshot",
+          usage,
+          message: "snapshot id is required"
+        }), { format: input.format });
+      }
+    },
+    {
+      path: ["conversion-tracking", "contracts"],
+      usage: "canonry conversion-tracking contracts <project> [--format json|jsonl]",
+      run: async (input) => {
+        const usage = "canonry conversion-tracking contracts <project> [--format json|jsonl]";
+        await conversionTrackingContracts(createClient2(), requireProject(input, "conversion-tracking.contracts", usage), { format: input.format });
+      }
+    },
+    {
+      path: ["conversion-tracking", "contracts", "get"],
+      usage: "canonry conversion-tracking contracts get <project> <contract-id> [--format json]",
+      run: async (input) => {
+        const usage = "canonry conversion-tracking contracts get <project> <contract-id> [--format json]";
+        const project = requireProject(input, "conversion-tracking.contracts.get", usage);
+        await conversionTrackingContract(createClient2(), project, requirePositional(input, 1, {
+          command: "conversion-tracking.contracts.get",
+          usage,
+          message: "contract id is required"
+        }), { format: input.format });
+      }
+    },
+    {
+      path: ["conversion-tracking", "contracts", "create"],
+      usage: "canonry conversion-tracking contracts create <project> --input <json-file|-> [--format json]",
+      options: { input: stringOption() },
+      run: async (input) => {
+        const usage = "canonry conversion-tracking contracts create <project> --input <json-file|-> [--format json]";
+        await conversionTrackingCreate(createClient2(), requireProject(input, "conversion-tracking.contracts.create", usage), readConversionTrackingContractInput(getString(input.values, "input")), { format: input.format });
+      }
+    },
+    {
+      path: ["conversion-tracking", "contracts", "update"],
+      usage: "canonry conversion-tracking contracts update <project> <contract-id> --input <json-file|-> [--format json]",
+      options: { input: stringOption() },
+      run: async (input) => {
+        const usage = "canonry conversion-tracking contracts update <project> <contract-id> --input <json-file|-> [--format json]";
+        const project = requireProject(input, "conversion-tracking.contracts.update", usage);
+        const contractId = requirePositional(input, 1, { command: "conversion-tracking.contracts.update", usage, message: "contract id is required" });
+        await conversionTrackingUpdate(createClient2(), project, contractId, readConversionTrackingContractInput(getString(input.values, "input")), { format: input.format });
+      }
+    },
+    {
+      path: ["conversion-tracking", "contracts", "delete"],
+      usage: "canonry conversion-tracking contracts delete <project> <contract-id> [--format json]",
+      run: async (input) => {
+        const usage = "canonry conversion-tracking contracts delete <project> <contract-id> [--format json]";
+        const project = requireProject(input, "conversion-tracking.contracts.delete", usage);
+        await conversionTrackingDelete(createClient2(), project, requirePositional(input, 1, {
+          command: "conversion-tracking.contracts.delete",
+          usage,
+          message: "contract id is required"
+        }), { format: input.format });
+      }
+    },
+    {
+      path: ["conversion-tracking", "contracts", "integrity"],
+      usage: "canonry conversion-tracking contracts integrity <project> <contract-id> [--format json|jsonl]",
+      run: async (input) => {
+        const usage = "canonry conversion-tracking contracts integrity <project> <contract-id> [--format json|jsonl]";
+        const project = requireProject(input, "conversion-tracking.contracts.integrity", usage);
+        await conversionTrackingIntegrity(createClient2(), project, requirePositional(input, 1, {
+          command: "conversion-tracking.contracts.integrity",
+          usage,
+          message: "contract id is required"
+        }), { format: input.format });
+      }
+    }
+  ];
+}
+
 // src/commands/get.ts
 var SOURCE_FETCHERS = {
   overview: async (project) => createApiClient().getProjectOverview(project),
@@ -5336,12 +5914,12 @@ var GET_CLI_COMMANDS = [
 ];
 
 // src/commands/traffic.ts
-import fs5 from "fs";
+import fs6 from "fs";
 
 // src/cloudflare-worker-deploy.ts
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import fs4 from "fs";
+import fs5 from "fs";
 import os from "os";
 import path2 from "path";
 import { stripVTControlCharacters } from "util";
@@ -5359,7 +5937,7 @@ function projectSlug(project) {
 }
 function lstatIfPresent(filePath) {
   try {
-    return fs4.lstatSync(filePath);
+    return fs5.lstatSync(filePath);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -5377,7 +5955,7 @@ function prepareCloudflareWorkerOutputDirectory(outputDirectory) {
       throw new Error(`output directory is not a regular directory: ${resolved}`);
     }
   } else {
-    fs4.mkdirSync(resolved, { recursive: true, mode: 448 });
+    fs5.mkdirSync(resolved, { recursive: true, mode: 448 });
   }
   const artifacts = {
     outputDirectory: resolved,
@@ -5390,7 +5968,7 @@ function prepareCloudflareWorkerOutputDirectory(outputDirectory) {
     if (!stat.isFile() || stat.isSymbolicLink()) {
       throw new Error(`artifact path is not a regular file: ${artifactPath}`);
     }
-    const contents = fs4.readFileSync(artifactPath, "utf-8");
+    const contents = fs5.readFileSync(artifactPath, "utf-8");
     if (!isRecognizablyCanonryGenerated(artifactPath, contents)) {
       throw new Error(`refusing to overwrite an operator-owned artifact: ${artifactPath}`);
     }
@@ -5403,7 +5981,7 @@ function readRegularArtifact(filePath) {
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error(`artifact path is not a regular file: ${filePath}`);
   }
-  return fs4.readFileSync(filePath, "utf-8");
+  return fs5.readFileSync(filePath, "utf-8");
 }
 function isRecognizablyCanonryGenerated(filePath, contents) {
   if (path2.basename(filePath) === "worker.js") {
@@ -5420,22 +5998,22 @@ function writePrivateTemporaryFile(filePath, contents) {
     path2.dirname(filePath),
     `.${path2.basename(filePath)}.${randomUUID()}.tmp`
   );
-  const fd = fs4.openSync(temporaryPath, "wx", 384);
+  const fd = fs5.openSync(temporaryPath, "wx", 384);
   let closed = false;
   try {
-    fs4.writeFileSync(fd, contents, "utf-8");
-    fs4.fsyncSync(fd);
-    fs4.closeSync(fd);
+    fs5.writeFileSync(fd, contents, "utf-8");
+    fs5.fsyncSync(fd);
+    fs5.closeSync(fd);
     closed = true;
   } catch (error) {
     if (!closed) {
       try {
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
       } catch {
       }
     }
     try {
-      fs4.unlinkSync(temporaryPath);
+      fs5.unlinkSync(temporaryPath);
     } catch {
     }
     throw error;
@@ -5469,10 +6047,10 @@ function writeCloudflareWorkerArtifacts(artifacts, contents) {
         throw new Error(`artifact changed during update: ${change.filePath}`);
       }
       if (change.previous === null) {
-        fs4.linkSync(change.temporaryPath, change.filePath);
-        fs4.unlinkSync(change.temporaryPath);
+        fs5.linkSync(change.temporaryPath, change.filePath);
+        fs5.unlinkSync(change.temporaryPath);
       } else {
-        fs4.renameSync(change.temporaryPath, change.filePath);
+        fs5.renameSync(change.temporaryPath, change.filePath);
       }
       applied.push(change);
     }
@@ -5481,10 +6059,10 @@ function writeCloudflareWorkerArtifacts(artifacts, contents) {
       try {
         if (readRegularArtifact(change.filePath) !== change.contents) continue;
         if (change.previous === null) {
-          fs4.unlinkSync(change.filePath);
+          fs5.unlinkSync(change.filePath);
         } else {
           const restorePath = writePrivateTemporaryFile(change.filePath, change.previous);
-          fs4.renameSync(restorePath, change.filePath);
+          fs5.renameSync(restorePath, change.filePath);
         }
       } catch {
       }
@@ -5493,7 +6071,7 @@ function writeCloudflareWorkerArtifacts(artifacts, contents) {
   } finally {
     for (const change of pending) {
       try {
-        if (fs4.existsSync(change.temporaryPath)) fs4.unlinkSync(change.temporaryPath);
+        if (fs5.existsSync(change.temporaryPath)) fs5.unlinkSync(change.temporaryPath);
       } catch {
       }
     }
@@ -5579,7 +6157,7 @@ async function preflightCloudflareWrangler(opts = {}) {
   if (missing.length > 0) {
     throw new Error(`Wrangler deploy does not support required flags: ${missing.join(", ")}`);
   }
-  const tempDirectory = fs4.mkdtempSync(path2.join(
+  const tempDirectory = fs5.mkdtempSync(path2.join(
     opts.tempRoot ?? os.tmpdir(),
     "canonry-cloudflare-wrangler-preflight-"
   ));
@@ -5587,13 +6165,13 @@ async function preflightCloudflareWrangler(opts = {}) {
   const wranglerTomlPath = path2.join(tempDirectory, "wrangler.toml");
   const secretsPath = path2.join(tempDirectory, "secrets.json");
   try {
-    fs4.chmodSync(tempDirectory, 448);
-    fs4.writeFileSync(workerScriptPath, generateWorkerScript({
+    fs5.chmodSync(tempDirectory, 448);
+    fs5.writeFileSync(workerScriptPath, generateWorkerScript({
       deliveryMode,
       workerVersion: "preflight",
       botList: DEFAULT_BOT_LIST
     }), { encoding: "utf-8", flag: "wx", mode: 384 });
-    fs4.writeFileSync(wranglerTomlPath, generateWranglerToml(
+    fs5.writeFileSync(wranglerTomlPath, generateWranglerToml(
       deliveryMode === "queue-pull" ? {
         deliveryMode,
         sourceId: "preflight",
@@ -5609,7 +6187,7 @@ async function preflightCloudflareWrangler(opts = {}) {
       }
     ), { encoding: "utf-8", flag: "wx", mode: 384 });
     if (deliveryMode === "direct-push") {
-      fs4.writeFileSync(secretsPath, JSON.stringify({
+      fs5.writeFileSync(secretsPath, JSON.stringify({
         [CLOUDFLARE_WORKER_BINDINGS.bearerToken]: "preflight-bearer",
         [CLOUDFLARE_WORKER_BINDINGS.hmacSecret]: "preflight-hmac"
       }), { encoding: "utf-8", flag: "wx", mode: 384 });
@@ -5637,7 +6215,7 @@ ${wranglerDiagnostic(validationOutput)}`
       );
     }
   } finally {
-    fs4.rmSync(tempDirectory, { recursive: true, force: true });
+    fs5.rmSync(tempDirectory, { recursive: true, force: true });
   }
 }
 async function deployCloudflareWorker(opts) {
@@ -5653,11 +6231,11 @@ async function deployCloudflareWorker(opts) {
   }
   if (!opts.secrets) throw new Error("Direct-push Worker deploy requires bearer and HMAC secrets");
   const secrets = opts.secrets;
-  const tempDirectory = fs4.mkdtempSync(path2.join(opts.tempRoot ?? os.tmpdir(), "canonry-cloudflare-secrets-"));
+  const tempDirectory = fs5.mkdtempSync(path2.join(opts.tempRoot ?? os.tmpdir(), "canonry-cloudflare-secrets-"));
   const secretsPath = path2.join(tempDirectory, "secrets.json");
   try {
-    fs4.chmodSync(tempDirectory, 448);
-    fs4.writeFileSync(
+    fs5.chmodSync(tempDirectory, 448);
+    fs5.writeFileSync(
       secretsPath,
       JSON.stringify({
         [CLOUDFLARE_WORKER_BINDINGS.bearerToken]: secrets.bearerToken,
@@ -5665,7 +6243,7 @@ async function deployCloudflareWorker(opts) {
       }),
       { encoding: "utf-8", flag: "wx", mode: 384 }
     );
-    fs4.chmodSync(secretsPath, 384);
+    fs5.chmodSync(secretsPath, 384);
     const runner = opts.run ?? runWrangler;
     await runner(
       "wrangler",
@@ -5681,9 +6259,9 @@ async function deployCloudflareWorker(opts) {
     );
   } finally {
     try {
-      if (fs4.existsSync(secretsPath)) fs4.unlinkSync(secretsPath);
+      if (fs5.existsSync(secretsPath)) fs5.unlinkSync(secretsPath);
     } finally {
-      fs4.rmSync(tempDirectory, { recursive: true, force: true });
+      fs5.rmSync(tempDirectory, { recursive: true, force: true });
     }
   }
 }
@@ -5713,11 +6291,11 @@ function requireCloudflareQueueOption(project, value, option) {
 }
 function readCloudflareQueueApiToken(project, tokenFile) {
   try {
-    const stat = fs5.lstatSync(tokenFile);
+    const stat = fs6.lstatSync(tokenFile);
     if (!stat.isFile() || stat.isSymbolicLink()) {
       throw new Error("not a regular file");
     }
-    const apiToken = fs5.readFileSync(tokenFile, "utf-8").trim();
+    const apiToken = fs6.readFileSync(tokenFile, "utf-8").trim();
     if (!apiToken) throw new Error("file is empty");
     return apiToken;
   } catch (error) {
@@ -5999,9 +6577,9 @@ async function trafficConnectWordpress(project, opts) {
   }
   let applicationPassword = opts.appPassword?.trim() ?? "";
   if (!applicationPassword && opts.appPasswordFile) {
-    const fs19 = await import("fs");
+    const fs20 = await import("fs");
     try {
-      applicationPassword = fs19.readFileSync(opts.appPasswordFile, "utf-8").trim();
+      applicationPassword = fs20.readFileSync(opts.appPasswordFile, "utf-8").trim();
     } catch (e) {
       const msg = describeError(e);
       throw new CliError({
@@ -6057,10 +6635,10 @@ async function trafficConnectCloudRun(project, opts) {
       details: { project }
     });
   }
-  const fs19 = await import("fs");
+  const fs20 = await import("fs");
   let keyJson;
   try {
-    keyJson = fs19.readFileSync(opts.serviceAccountKey, "utf-8");
+    keyJson = fs20.readFileSync(opts.serviceAccountKey, "utf-8");
     JSON.parse(keyJson);
   } catch (e) {
     const msg = describeError(e);
@@ -6120,9 +6698,9 @@ async function trafficConnectVercel(project, opts) {
   }
   let token = opts.token?.trim() ?? "";
   if (!token && opts.tokenFile) {
-    const fs19 = await import("fs");
+    const fs20 = await import("fs");
     try {
-      token = fs19.readFileSync(opts.tokenFile, "utf-8").trim();
+      token = fs20.readFileSync(opts.tokenFile, "utf-8").trim();
     } catch (e) {
       const msg = describeError(e);
       throw new CliError({
@@ -8570,7 +9148,7 @@ var USERS_CLI_COMMANDS = [
 ];
 
 // src/commands/keyword.ts
-import fs6 from "fs";
+import fs7 from "fs";
 function getClient14() {
   return createApiClient();
 }
@@ -8638,7 +9216,7 @@ async function listKeywords(project, format) {
   }
 }
 async function importKeywords(project, filePath, format) {
-  if (!fs6.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     throw new CliError({
       code: "KEYWORD_IMPORT_FILE_NOT_FOUND",
       message: `File not found: ${filePath}`,
@@ -8649,7 +9227,7 @@ async function importKeywords(project, filePath, format) {
       }
     });
   }
-  const content = fs6.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   const keywords = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   if (keywords.length === 0) {
     if (isMachineFormat(format)) {
@@ -8850,7 +9428,7 @@ var KEYWORD_CLI_COMMANDS = [
 ];
 
 // src/commands/query.ts
-import fs7 from "fs";
+import fs8 from "fs";
 function getClient15() {
   return createApiClient();
 }
@@ -8941,7 +9519,7 @@ async function listQueries(project, format) {
   }
 }
 async function importQueries(project, filePath, format) {
-  if (!fs7.existsSync(filePath)) {
+  if (!fs8.existsSync(filePath)) {
     throw new CliError({
       code: "QUERY_IMPORT_FILE_NOT_FOUND",
       message: `File not found: ${filePath}`,
@@ -8952,7 +9530,7 @@ async function importQueries(project, filePath, format) {
       }
     });
   }
-  const content = fs7.readFileSync(filePath, "utf-8");
+  const content = fs8.readFileSync(filePath, "utf-8");
   const queries2 = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   if (queries2.length === 0) {
     if (isMachineFormat(format)) {
@@ -9154,7 +9732,7 @@ var QUERY_CLI_COMMANDS = [
 ];
 
 // src/commands/mcp.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path4 from "path";
 import { createRequire } from "module";
 
@@ -9270,8 +9848,8 @@ function renderClientSnippet(client, serverName, entry) {
   return renderJsonSnippet(serverName, entry, client.format);
 }
 function readJsonConfig(configPath) {
-  if (!fs8.existsSync(configPath)) return {};
-  const raw = fs8.readFileSync(configPath, "utf-8").trim();
+  if (!fs9.existsSync(configPath)) return {};
+  const raw = fs9.readFileSync(configPath, "utf-8").trim();
   if (!raw) return {};
   try {
     const parsed = JSON.parse(raw);
@@ -9289,14 +9867,14 @@ function readJsonConfig(configPath) {
   }
 }
 function writeJsonConfig(configPath, value) {
-  fs8.mkdirSync(path4.dirname(configPath), { recursive: true });
-  fs8.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
+  fs9.mkdirSync(path4.dirname(configPath), { recursive: true });
+  fs9.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
 }
 function backupConfigIfPresent(configPath) {
-  if (!fs8.existsSync(configPath)) return void 0;
+  if (!fs9.existsSync(configPath)) return void 0;
   const backupPath = `${configPath}.canonry.bak`;
-  fs8.copyFileSync(configPath, backupPath);
+  fs9.copyFileSync(configPath, backupPath);
   return backupPath;
 }
 function findClientOrThrow(id) {
@@ -9652,13 +10230,13 @@ var NOTIFY_CLI_COMMANDS = [
 ];
 
 // src/commands/apply.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import { parseAllDocuments } from "yaml";
 async function applyConfigFile(filePath) {
-  if (!fs9.existsSync(filePath)) {
+  if (!fs10.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const content = fs10.readFileSync(filePath, "utf-8");
   const docs = parseAllDocuments(content);
   const client = createApiClient();
   const errors = [];
@@ -10061,7 +10639,7 @@ async function loadLatestRunForExport(client, project) {
 }
 
 // src/commands/results-export.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path5 from "path";
 async function exportResults(project, opts) {
   const { output, ...request } = opts;
@@ -10071,8 +10649,8 @@ async function exportResults(project, opts) {
     return;
   }
   const target = output ? path5.resolve(output) : path5.resolve(process.cwd(), path5.basename(artifact.filename));
-  fs10.mkdirSync(path5.dirname(target), { recursive: true });
-  fs10.writeFileSync(target, artifact.content, "utf8");
+  fs11.mkdirSync(path5.dirname(target), { recursive: true });
+  fs11.writeFileSync(target, artifact.content, "utf8");
   console.log(`Results export written to ${target}`);
 }
 
@@ -10788,7 +11366,7 @@ function parseProviderModelAssignments(assignments) {
 }
 
 // src/commands/report.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path6 from "path";
 function defaultOutputPath(project, audience) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -10805,10 +11383,10 @@ async function runReportCommand(project, opts = {}) {
   const html = renderReportHtml(report, { audience });
   const targetPath = opts.output ? path6.resolve(opts.output) : defaultOutputPath(project, audience);
   const dir = path6.dirname(targetPath);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
-  fs11.writeFileSync(targetPath, html, "utf-8");
+  fs12.writeFileSync(targetPath, html, "utf-8");
   console.log(`Report written to ${targetPath}`);
 }
 
@@ -11783,11 +12361,11 @@ var SKILLS_CLI_COMMANDS = [
 ];
 
 // src/commands/snapshot.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import path8 from "path";
 
 // src/snapshot-pdf.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path7 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
@@ -12001,8 +12579,8 @@ async function writeSnapshotPdf(report, outputPath) {
   renderQueries(pdf, report);
   const bytes = await doc.save();
   const resolvedPath = path7.resolve(outputPath);
-  fs12.mkdirSync(path7.dirname(resolvedPath), { recursive: true });
-  fs12.writeFileSync(resolvedPath, bytes);
+  fs13.mkdirSync(path7.dirname(resolvedPath), { recursive: true });
+  fs13.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -12161,8 +12739,8 @@ PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
   const resolvedPath = path8.resolve(outputPath);
-  fs13.mkdirSync(path8.dirname(resolvedPath), { recursive: true });
-  fs13.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  fs14.mkdirSync(path8.dirname(resolvedPath), { recursive: true });
+  fs14.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -13390,7 +13968,7 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn as spawn2 } from "child_process";
-import fs14 from "fs";
+import fs15 from "fs";
 import path10 from "path";
 function getPidPath() {
   return path10.join(getConfigDir(), "canonry.pid");
@@ -13433,8 +14011,8 @@ function buildServeForwardArgs(opts) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs14.existsSync(pidPath)) {
-    const existingPid = parseInt(fs14.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs15.existsSync(pidPath)) {
+    const existingPid = parseInt(fs15.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -13445,7 +14023,7 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs14.unlinkSync(pidPath);
+    fs15.unlinkSync(pidPath);
   }
   const cliPath = path10.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
@@ -13464,10 +14042,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs14.existsSync(configDir)) {
-    fs14.mkdirSync(configDir, { recursive: true });
+  if (!fs15.existsSync(configDir)) {
+    fs15.mkdirSync(configDir, { recursive: true });
   }
-  fs14.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs15.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (!isMachineFormat(format)) {
@@ -13476,7 +14054,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs14.unlinkSync(pidPath);
+      fs15.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -13508,7 +14086,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs14.existsSync(pidPath)) {
+  if (!fs15.existsSync(pidPath)) {
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
         stopped: false,
@@ -13519,7 +14097,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs14.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs15.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
@@ -13530,7 +14108,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs14.unlinkSync(pidPath);
+    fs15.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -13544,12 +14122,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs14.unlinkSync(pidPath);
+    fs15.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs14.unlinkSync(pidPath);
+    fs15.unlinkSync(pidPath);
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
         stopped: true,
@@ -13573,7 +14151,7 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs15 from "fs";
+import fs16 from "fs";
 import readline2 from "readline";
 import path11 from "path";
 var pendingServeHandoff = false;
@@ -13611,7 +14189,7 @@ var PROJECT_MARKERS = [".git", "canonry.yaml", "canonry.yml", "package.json"];
 function cwdLooksLikeProject(dir) {
   const home = process.env.HOME ?? "";
   if (home && path11.resolve(dir) === path11.resolve(home)) return false;
-  return PROJECT_MARKERS.some((marker) => fs15.existsSync(path11.join(dir, marker)));
+  return PROJECT_MARKERS.some((marker) => fs16.existsSync(path11.join(dir, marker)));
 }
 var DEFAULT_AGENT_MODELS = {
   anthropic: "anthropic/claude-sonnet-4-6",
@@ -13642,8 +14220,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs15.existsSync(configDir)) {
-    fs15.mkdirSync(configDir, { recursive: true });
+  if (!fs16.existsSync(configDir)) {
+    fs16.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -13944,7 +14522,7 @@ function encodeLegacySetupState(state) {
 }
 
 // src/agent-plugin.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path12 from "path";
 var CANONRY_PLUGIN_ID = "canonry@canonry";
 var REQUIRED_SKILLS = ["canonry", "aero"];
@@ -13989,7 +14567,7 @@ function isCanonryPluginId(value) {
 }
 function readJson(filePath) {
   try {
-    return JSON.parse(fs16.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs17.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -14008,7 +14586,7 @@ function readCodexPluginConfigured(filePath) {
   try {
     let currentPlugin = null;
     let inPluginsTable = false;
-    for (const line of fs16.readFileSync(filePath, "utf8").split(/\r?\n/)) {
+    for (const line of fs17.readFileSync(filePath, "utf8").split(/\r?\n/)) {
       const section = /^\s*\[plugins\.(?:"([^"]+)"|'([^']+)'|(\S+))\]\s*(?:#.*)?$/.exec(line);
       if (section) {
         const captures = section.slice(1, 4);
@@ -14041,7 +14619,7 @@ function readCodexPluginConfigured(filePath) {
   }
 }
 function verifiedPluginVersion(root, client) {
-  if (client === "codex" && fs16.existsSync(path12.join(root, "plugin.json"))) {
+  if (client === "codex" && fs17.existsSync(path12.join(root, "plugin.json"))) {
     const manifest2 = readJson(path12.join(root, "plugin.json"));
     if (manifest2 && typeof manifest2 === "object") {
       const plugin2 = manifest2;
@@ -14055,7 +14633,7 @@ function verifiedPluginVersion(root, client) {
         if (portableMcp.$schema !== AGENT_PLUGINS_MCP_SCHEMA || portableMcp.mcpServers?.canonry?.type !== "stdio" || portableMcp.mcpServers.canonry.command !== "canonry-mcp") {
           return null;
         }
-        return REQUIRED_SKILLS.every((name) => fs16.existsSync(path12.join(root, "skills", name, "SKILL.md"))) ? plugin2.version : null;
+        return REQUIRED_SKILLS.every((name) => fs17.existsSync(path12.join(root, "skills", name, "SKILL.md"))) ? plugin2.version : null;
       }
       if (typeof plugin2.$schema === "string" && plugin2.$schema.startsWith("https://agent-plugins.org/schemas/")) {
         return null;
@@ -14073,7 +14651,7 @@ function verifiedPluginVersion(root, client) {
   if (!mcp || typeof mcp !== "object") return null;
   const canonryServer = mcp.mcpServers?.canonry;
   if (canonryServer?.command !== "canonry-mcp") return null;
-  return REQUIRED_SKILLS.every((name) => fs16.existsSync(path12.join(root, "skills", name, "SKILL.md"))) ? plugin.version : null;
+  return REQUIRED_SKILLS.every((name) => fs17.existsSync(path12.join(root, "skills", name, "SKILL.md"))) ? plugin.version : null;
 }
 function readClaudeUserInstallPaths(claudeConfigDir) {
   const parsed = readJson(path12.join(claudeConfigDir, "plugins", "installed_plugins.json"));
@@ -14090,7 +14668,7 @@ function readClaudeUserInstallPaths(claudeConfigDir) {
 }
 function listDirectories(dir) {
   try {
-    return fs16.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path12.join(dir, entry.name));
+    return fs17.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path12.join(dir, entry.name));
   } catch {
     return [];
   }
@@ -15749,7 +16327,7 @@ var VISIBILITY_STATS_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs17 from "fs";
+import fs18 from "fs";
 
 // src/commands/wordpress.ts
 function getClient28() {
@@ -15988,12 +16566,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs19 = await import("fs/promises");
+  const fs20 = await import("fs/promises");
   const path13 = await import("path");
   const filePath = path13.resolve(opts.from);
   let raw;
   try {
-    raw = await fs19.readFile(filePath, "utf8");
+    raw = await fs20.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -16090,13 +16668,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs19 = await import("fs/promises");
+  const fs20 = await import("fs/promises");
   const path13 = await import("path");
   const yaml = await loadYamlModule();
   const filePath = path13.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs19.readFile(filePath, "utf8");
+    raw = await fs20.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -16201,13 +16779,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs19 = await import("fs/promises");
+    const fs20 = await import("fs/promises");
     const path13 = await import("path");
     const yaml = await loadYamlModule();
     const filePath = path13.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs19.readFile(filePath, "utf8");
+      raw = await fs20.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -16356,7 +16934,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs17.readFileSync(contentFile, "utf-8");
+      return fs18.readFileSync(contentFile, "utf-8");
     } catch (error) {
       const message = describeError(error);
       throw usageError(`Error: could not read --content-file "${contentFile}": ${message}`, {
@@ -17323,16 +17901,16 @@ Usage: ${usage}`, {
 
 // src/commands/measurement-plan.ts
 import crypto3 from "crypto";
-import fs18 from "fs";
+import fs19 from "fs";
 import { parse } from "yaml";
 import { z as z2 } from "zod";
 function readPlan(source) {
-  const content = source === "-" ? fs18.readFileSync(0, "utf8") : fs18.readFileSync(source, "utf8");
+  const content = source === "-" ? fs19.readFileSync(0, "utf8") : fs19.readFileSync(source, "utf8");
   const parsed = source.endsWith(".json") ? JSON.parse(content) : parse(content);
   return measurementPlanInputSchema.parse(parsed);
 }
 function readDiscoveryRule(source) {
-  const content = source === "-" ? fs18.readFileSync(0, "utf8") : fs18.readFileSync(source, "utf8");
+  const content = source === "-" ? fs19.readFileSync(0, "utf8") : fs19.readFileSync(source, "utf8");
   const parsed = source.endsWith(".json") ? JSON.parse(content) : parse(content);
   return measurementDiscoveryRuleSchema.parse(parsed);
 }
@@ -17381,7 +17959,7 @@ var advancedDeactivateInputSchema = z2.object({
 }).strict();
 function readAdvancedMeasurementInput(source) {
   if (source === void 0) return {};
-  const content = source === "-" ? fs18.readFileSync(0, "utf8") : fs18.readFileSync(source, "utf8");
+  const content = source === "-" ? fs19.readFileSync(0, "utf8") : fs19.readFileSync(source, "utf8");
   return JSON.parse(content);
 }
 var advancedMeasurementCollectionKeys = {
@@ -17563,7 +18141,7 @@ async function replaceMeasurementPlanAssignments(project, opts) {
   console.log(JSON.stringify({ preview, result }, null, 2));
 }
 function readGroupMembershipCsv(source) {
-  return source === "-" ? fs18.readFileSync(0, "utf8") : fs18.readFileSync(source, "utf8");
+  return source === "-" ? fs19.readFileSync(0, "utf8") : fs19.readFileSync(source, "utf8");
 }
 async function previewMeasurementPlanGroups(project, source) {
   const preview = await createApiClient().previewMeasurementDraftGroupMembership(project, {
@@ -17994,6 +18572,7 @@ var REGISTERED_CLI_COMMANDS = [
   ...ADS_CLI_COMMANDS,
   ...GA_CLI_COMMANDS,
   ...GBP_CLI_COMMANDS,
+  ...createGoogleMarketingCliCommands(createApiClient),
   ...TRAFFIC_CLI_COMMANDS,
   ...INTELLIGENCE_CLI_COMMANDS,
   ...VISIBILITY_STATS_CLI_COMMANDS,