@canonry/canonry 4.117.2 → 4.123.0

package/dist/cli.js

@@ -29,7 +29,7 @@ import {
   setTelemetrySource,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-F2SRZJMY.js";
+} from "./chunk-JYBNBK25.js";
 import {
   CliError,
   EXIT_SYSTEM_ERROR,
@@ -46,7 +46,7 @@ import {
   saveConfig,
   saveConfigPatch,
   usageError
-} from "./chunk-4PMMEFME.js";
+} from "./chunk-HJIIJI7K.js";
 import {
   apiKeys,
   createClient,
@@ -54,8 +54,11 @@ import {
   projects,
   queries,
   renderReportHtml
-} from "./chunk-BMPIV35C.js";
+} from "./chunk-4AZ7VES6.js";
 import {
+  AdsOperationKinds,
+  AdsOperationStates,
+  AdsOperationStepStates,
   BacklinkSources,
   CcReleaseSyncStatuses,
   CheckScopes,
@@ -65,7 +68,19 @@ import {
   REPORT_PERIOD_OPTIONS,
   RunStatuses,
   TrafficEventKinds,
+  adsActivateTreeRequestSchema,
+  adsActivationGrantCreateRequestSchema,
+  adsAdCreateRequestSchema,
+  adsAdGroupCreateRequestSchema,
+  adsAdGroupUpdateRequestSchema,
+  adsAdUpdateRequestSchema,
+  adsCampaignCreateRequestSchema,
+  adsCampaignUpdateRequestSchema,
+  adsGeoSearchQuerySchema,
+  adsImageUploadRequestSchema,
+  adsPauseRequestSchema,
   backlinkSourceSchema,
+  buildModelChangeNotice,
   discoveryBucketSchema,
   discoveryCompetitorTypeSchema,
   effectiveDomains,
@@ -80,7 +95,7 @@ import {
   providerQuotaPolicySchema,
   resolveProviderInput,
   winnabilityClassSchema
-} from "./chunk-EZME2J2G.js";
+} from "./chunk-MMFSI3OG.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
@@ -2713,9 +2728,80 @@ var DOCTOR_CLI_COMMANDS = [
 ];
 
 // src/commands/ads.ts
+import fs3 from "fs";
 function getClient5() {
   return createApiClient();
 }
+function readRequest(inputPath, schema) {
+  if (!inputPath) {
+    throw new CliError({
+      code: "ADS_INPUT_REQUIRED",
+      message: "A JSON input file is required",
+      displayMessage: "Error: --input <json-file> is required (use --input - for stdin)"
+    });
+  }
+  try {
+    const raw = fs3.readFileSync(inputPath === "-" ? 0 : inputPath, "utf8");
+    return schema.parse(JSON.parse(raw));
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    throw new CliError({
+      code: "ADS_INPUT_INVALID",
+      message: err instanceof Error ? err.message : String(err),
+      displayMessage: `Error: invalid ads JSON input (${err instanceof Error ? err.message : String(err)})`,
+      details: { inputPath }
+    });
+  }
+}
+function printOperationDetails(operation) {
+  console.log(`Operation: ${operation.operationKey}`);
+  if (operation.entityId) console.log(`Entity:    ${operation.entityType ?? "unknown"} ${operation.entityId}`);
+  if (operation.upstreamUpdatedAt != null) console.log(`Updated:   ${operation.upstreamUpdatedAt}`);
+  if (operation.errorCode) console.log(`Error:     ${operation.errorCode}: ${operation.errorMessage ?? ""}`);
+  if (operation.state === AdsOperationStates.pending || operation.state === AdsOperationStates.unknown || operation.state === AdsOperationStates.reconciling) {
+    if (operation.kind === AdsOperationKinds.campaign_tree_activate) {
+      console.log("Do not retry with a new operation key. Resume activation recovery for the original receipt instead.");
+    } else {
+      console.log("Do not retry with a new operation key. Reconcile the original receipt instead.");
+    }
+  }
+}
+function printOperation(result, format) {
+  if (isMachineFormat(format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`${result.replayed ? "Replayed" : "Recorded"} ${result.operation.kind}: ${result.operation.state}`);
+  printOperationDetails(result.operation);
+}
+function printReconciliation(result, format) {
+  if (isMachineFormat(format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`${result.resolved ? "Resolved" : "Still unresolved"} ${result.operation.kind}: ${result.operation.state}`);
+  printOperationDetails(result.operation);
+}
+function printActivationGrant(result, verb, format) {
+  if (isMachineFormat(format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const cancellationRequested = verb === "Revoked" && result.grant.revocationRequestedAt !== null;
+  console.log(cancellationRequested ? `Cancellation requested for activation grant ${result.grant.id}: ${result.grant.state}` : `${verb} activation grant ${result.grant.id}: ${result.grant.state}`);
+  if (cancellationRequested) console.log(`Requested: ${result.grant.revocationRequestedAt}`);
+  console.log(`Manifest: ${result.grant.manifestHash}`);
+  console.log(`Expires:  ${result.grant.expiresAt}`);
+}
+function printActivation(result, format) {
+  if (isMachineFormat(format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const activeSteps = result.steps.filter((step) => step.state === AdsOperationStepStates.active).length;
+  console.log(`Activation ${result.operation.operationKey}: ${result.operation.state}`);
+  console.log(`Steps:      ${activeSteps}/${result.steps.length} active`);
+}
 function describeConnection(status) {
   const lines = [];
   lines.push(`Connected:    ${status.connected ? "yes" : "no"}`);
@@ -2768,6 +2854,199 @@ async function adsStatus(project, opts) {
     console.log("Connect with: canonry ads connect " + project + " --api-key <sdk-key>");
   }
 }
+async function adsAccount(project, opts) {
+  const result = await getClient5().getAdsAccount(project);
+  if (isMachineFormat(opts?.format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Account:    ${result.name}`);
+  console.log(`ID:         ${result.id}`);
+  console.log(`Status:     ${result.status}`);
+  console.log(`Currency:   ${result.currencyCode ?? "unknown"}`);
+  console.log(`Timezone:   ${result.timezone ?? "unknown"}`);
+  console.log(`Review:     ${result.reviewStatus ?? "unknown"}`);
+  console.log(`Integrity:  ${result.integrityReviewStatus ?? "unknown"}`);
+  if (result.integrityDecision) console.log(`Decision:   ${result.integrityDecision}`);
+  if (result.url) console.log(`Ads Manager: ${result.url}`);
+}
+async function adsGeoSearch(project, opts) {
+  const parsed = adsGeoSearchQuerySchema.safeParse({ q: opts.q, limit: opts.limit });
+  if (!parsed.success) {
+    throw new CliError({
+      code: "ADS_GEO_QUERY_INVALID",
+      message: "A valid geo search query is required",
+      displayMessage: "Error: --query is required and --limit must be an integer from 1 to 100",
+      details: {
+        project,
+        issues: parsed.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }))
+      }
+    });
+  }
+  const query = parsed.data;
+  const result = await getClient5().searchAdsGeo(project, query);
+  if (opts.format === "jsonl") {
+    emitJsonl(result.results.map((location) => ({ project, query: result.query, ...location })));
+    return;
+  }
+  if (isMachineFormat(opts.format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.results.length === 0) {
+    console.log(`No OpenAI Ads locations matched "${result.query}".`);
+    return;
+  }
+  for (const location of result.results) {
+    const region = location.regionCode ? `, ${location.regionCode}` : "";
+    console.log(`${location.canonicalName} (${location.type}, ${location.countryCode}${region}) [${location.id}]`);
+  }
+}
+async function adsConversionPixels(project, opts) {
+  const result = await getClient5().getAdsConversionPixels(project);
+  if (opts?.format === "jsonl") {
+    emitJsonl(result.pixels.map((pixel) => ({ project, ...pixel })));
+    return;
+  }
+  if (isMachineFormat(opts?.format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.pixels.length === 0) {
+    console.log("No OpenAI Ads conversion pixels are configured.");
+    return;
+  }
+  for (const pixel of result.pixels) {
+    const name = pixel.name ?? "Unnamed conversion pixel";
+    const clientType = pixel.clientType ?? "unknown client";
+    const pixelId = pixel.pixelId ? ` pixel ${pixel.pixelId}` : "";
+    console.log(`${name} (${clientType}) [${pixel.id}]${pixelId}`);
+  }
+}
+async function adsConversionEventSettings(project, opts) {
+  const result = await getClient5().getAdsConversionEventSettings(project);
+  if (opts?.format === "jsonl") {
+    emitJsonl(result.eventSettings.map((eventSetting) => ({ project, ...eventSetting })));
+    return;
+  }
+  if (isMachineFormat(opts?.format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.eventSettings.length === 0) {
+    console.log("No OpenAI Ads conversion event settings are configured.");
+    return;
+  }
+  for (const eventSetting of result.eventSettings) {
+    const name = eventSetting.name ?? "Unnamed conversion event";
+    const eventType = eventSetting.eventType ?? "unknown event";
+    const attribution = eventSetting.attributionWindowDays === void 0 ? "unknown attribution window" : `${eventSetting.attributionWindowDays}d attribution`;
+    const sources = eventSetting.sources?.map((source) => source.name ?? source.id).join(", ") || "no source details";
+    const archived = eventSetting.archived === true ? " [archived]" : "";
+    console.log(
+      `${name}${archived}: ${eventType}, ${attribution}, ${sources} [${eventSetting.id}]`
+    );
+  }
+}
+async function adsOperationGet(project, opts) {
+  printOperation(await getClient5().getAdsOperation(project, opts.operationKey), opts.format);
+}
+async function adsOperationsUnresolved(project, opts) {
+  const query = {
+    state: opts?.state,
+    limit: opts?.limit,
+    cursor: opts?.cursor
+  };
+  const client = getClient5();
+  const result = Object.values(query).some((value) => value !== void 0) ? await client.getUnresolvedAdsOperations(project, query) : await client.getUnresolvedAdsOperations(project);
+  if (opts?.format === "jsonl") {
+    emitJsonl(result.operations.map((operation) => ({ project, ...operation })));
+    return;
+  }
+  if (isMachineFormat(opts?.format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.operations.length === 0) {
+    console.log("No unresolved OpenAI Ads mutation receipts.");
+    return;
+  }
+  console.log("STATE         KIND                  OPERATION KEY");
+  for (const operation of result.operations) {
+    console.log(`${operation.state.padEnd(13)} ${operation.kind.padEnd(21)} ${operation.operationKey}`);
+  }
+  if (result.nextCursor) console.log(`Next cursor: ${result.nextCursor}`);
+}
+async function adsOperationReconcile(project, opts) {
+  printReconciliation(
+    await getClient5().reconcileAdsOperation(project, opts.operationKey),
+    opts.format
+  );
+}
+async function adsOperationResumeActivation(project, opts) {
+  printActivation(
+    await getClient5().resumeAdsActivation(project, opts.operationKey),
+    opts.format
+  );
+}
+async function adsActivationGrantCreate(project, opts) {
+  const request = readRequest(
+    opts.input,
+    adsActivationGrantCreateRequestSchema
+  );
+  printActivationGrant(await getClient5().createAdsActivationGrant(project, request), "Approved", opts.format);
+}
+async function adsActivationGrantRevoke(project, grantId, opts) {
+  printActivationGrant(
+    await getClient5().revokeAdsActivationGrant(project, grantId),
+    "Revoked",
+    opts?.format
+  );
+}
+async function adsImageUpload(project, opts) {
+  const request = readRequest(opts.input, adsImageUploadRequestSchema);
+  printOperation(await getClient5().uploadAdsImage(project, request), opts.format);
+}
+async function adsCampaignCreate(project, opts) {
+  const request = readRequest(opts.input, adsCampaignCreateRequestSchema);
+  printOperation(await getClient5().createAdsCampaign(project, request), opts.format);
+}
+async function adsCampaignUpdate(project, campaignId, opts) {
+  const request = readRequest(opts.input, adsCampaignUpdateRequestSchema);
+  printOperation(await getClient5().updateAdsCampaign(project, campaignId, request), opts.format);
+}
+async function adsCampaignPause(project, campaignId, opts) {
+  const request = readRequest(opts.input, adsPauseRequestSchema);
+  printOperation(await getClient5().pauseAdsCampaign(project, campaignId, request), opts.format);
+}
+async function adsCampaignActivateTree(project, campaignId, opts) {
+  const request = readRequest(opts.input, adsActivateTreeRequestSchema);
+  printActivation(await getClient5().activateAdsCampaignTree(project, campaignId, request), opts.format);
+}
+async function adsAdGroupCreate(project, opts) {
+  const request = readRequest(opts.input, adsAdGroupCreateRequestSchema);
+  printOperation(await getClient5().createAdsAdGroup(project, request), opts.format);
+}
+async function adsAdGroupUpdate(project, adGroupId, opts) {
+  const request = readRequest(opts.input, adsAdGroupUpdateRequestSchema);
+  printOperation(await getClient5().updateAdsAdGroup(project, adGroupId, request), opts.format);
+}
+async function adsAdGroupPause(project, adGroupId, opts) {
+  const request = readRequest(opts.input, adsPauseRequestSchema);
+  printOperation(await getClient5().pauseAdsAdGroup(project, adGroupId, request), opts.format);
+}
+async function adsAdCreate(project, opts) {
+  const request = readRequest(opts.input, adsAdCreateRequestSchema);
+  printOperation(await getClient5().createAdsAd(project, request), opts.format);
+}
+async function adsAdUpdate(project, adId, opts) {
+  const request = readRequest(opts.input, adsAdUpdateRequestSchema);
+  printOperation(await getClient5().updateAdsAd(project, adId, request), opts.format);
+}
+async function adsAdPause(project, adId, opts) {
+  const request = readRequest(opts.input, adsPauseRequestSchema);
+  printOperation(await getClient5().pauseAdsAd(project, adId, request), opts.format);
+}
 async function adsSync(project, opts) {
   const client = getClient5();
   const result = await client.triggerAdsSync(project);
@@ -2885,6 +3164,285 @@ var ADS_CLI_COMMANDS = [
       await adsStatus(project, { format: input.format });
     }
   },
+  {
+    path: ["ads", "account"],
+    usage: "canonry ads account <project> [--format json]",
+    run: async (input) => {
+      const project = requireProject(input, "ads.account", "canonry ads account <project> [--format json]");
+      await adsAccount(project, { format: input.format });
+    }
+  },
+  {
+    path: ["ads", "geo", "search"],
+    usage: "canonry ads geo search <project> --query <text> [--limit <n>] [--format json|jsonl]",
+    options: {
+      query: stringOption(),
+      limit: stringOption()
+    },
+    run: async (input) => {
+      const usage = "canonry ads geo search <project> --query <text> [--limit <n>] [--format json|jsonl]";
+      const project = requireProject(input, "ads.geo.search", usage);
+      await adsGeoSearch(project, {
+        q: getString(input.values, "query"),
+        limit: parseIntegerOption(input, "limit", {
+          command: "ads.geo.search",
+          message: "--limit must be an integer from 1 to 100",
+          usage
+        }),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["ads", "conversions", "pixels"],
+    usage: "canonry ads conversions pixels <project> [--format json|jsonl]",
+    run: async (input) => {
+      const project = requireProject(input, "ads.conversions.pixels", "canonry ads conversions pixels <project> [--format json|jsonl]");
+      await adsConversionPixels(project, { format: input.format });
+    }
+  },
+  {
+    path: ["ads", "conversions", "event-settings"],
+    usage: "canonry ads conversions event-settings <project> [--format json|jsonl]",
+    run: async (input) => {
+      const project = requireProject(input, "ads.conversions.event-settings", "canonry ads conversions event-settings <project> [--format json|jsonl]");
+      await adsConversionEventSettings(project, { format: input.format });
+    }
+  },
+  {
+    path: ["ads", "operations", "unresolved"],
+    usage: "canonry ads operations unresolved <project> [--state <csv>] [--limit <n>] [--cursor <opaque>] [--format json|jsonl]",
+    options: {
+      state: stringOption(),
+      limit: stringOption(),
+      cursor: stringOption()
+    },
+    run: async (input) => {
+      const usage = "canonry ads operations unresolved <project> [--state <csv>] [--limit <n>] [--cursor <opaque>] [--format json|jsonl]";
+      const project = requireProject(
+        input,
+        "ads.operations.unresolved",
+        usage
+      );
+      const rawState = getString(input.values, "state");
+      const state = rawState === void 0 ? void 0 : rawState.split(",").filter((value) => value === "pending" || value === "unknown" || value === "reconciling");
+      if (rawState !== void 0 && state?.length !== rawState.split(",").length) {
+        throw usageError(`Error: --state must contain only pending, unknown, or reconciling
+Usage: ${usage}`, {
+          message: "--state must contain only pending, unknown, or reconciling",
+          details: { command: "ads.operations.unresolved", usage }
+        });
+      }
+      await adsOperationsUnresolved(project, {
+        state,
+        limit: parseIntegerOption(input, "limit", {
+          command: "ads.operations.unresolved",
+          message: "--limit must be an integer from 1 to 200",
+          usage
+        }),
+        cursor: getString(input.values, "cursor"),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["ads", "operation"],
+    usage: "canonry ads operation <project> <operation-key> [--format json]",
+    run: async (input) => {
+      const usage = "canonry ads operation <project> <operation-key> [--format json]";
+      const project = requireProject(input, "ads.operation", usage);
+      const operationKey = requirePositional(input, 1, {
+        command: "ads.operation",
+        usage,
+        message: "operation key is required"
+      });
+      await adsOperationGet(project, { operationKey, format: input.format });
+    }
+  },
+  {
+    path: ["ads", "operation", "reconcile"],
+    usage: "canonry ads operation reconcile <project> --operation-key <key> [--format json]",
+    options: {
+      "operation-key": stringOption()
+    },
+    run: async (input) => {
+      const usage = "canonry ads operation reconcile <project> --operation-key <key> [--format json]";
+      const project = requireProject(input, "ads.operation.reconcile", usage);
+      const operationKey = requireStringOption(input, "operation-key", {
+        command: "ads.operation.reconcile",
+        usage,
+        message: "--operation-key is required"
+      });
+      await adsOperationReconcile(project, {
+        operationKey,
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["ads", "operation", "resume-activation"],
+    usage: "canonry ads operation resume-activation <project> --operation-key <key> [--format json]",
+    options: { "operation-key": stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads operation resume-activation <project> --operation-key <key> [--format json]";
+      const project = requireProject(input, "ads.operation.resume-activation", usage);
+      await adsOperationResumeActivation(project, {
+        operationKey: requireStringOption(input, "operation-key", {
+          command: "ads.operation.resume-activation",
+          message: "--operation-key is required",
+          usage
+        }),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["ads", "activation-grant", "create"],
+    usage: "canonry ads activation-grant create <project> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads activation-grant create <project> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.activation-grant.create", usage);
+      await adsActivationGrantCreate(project, {
+        input: getString(input.values, "input"),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["ads", "activation-grant", "revoke"],
+    usage: "canonry ads activation-grant revoke <project> <grant-id> [--format json]",
+    run: async (input) => {
+      const usage = "canonry ads activation-grant revoke <project> <grant-id> [--format json]";
+      const project = requireProject(input, "ads.activation-grant.revoke", usage);
+      const grantId = requirePositional(input, 1, {
+        command: "ads.activation-grant.revoke",
+        usage,
+        message: "activation grant id is required"
+      });
+      await adsActivationGrantRevoke(project, grantId, { format: input.format });
+    }
+  },
+  {
+    path: ["ads", "image", "upload"],
+    usage: "canonry ads image upload <project> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const project = requireProject(input, "ads.image.upload", "canonry ads image upload <project> --input <json-file|-> [--format json]");
+      await adsImageUpload(project, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "campaign", "create"],
+    usage: "canonry ads campaign create <project> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const project = requireProject(input, "ads.campaign.create", "canonry ads campaign create <project> --input <json-file|-> [--format json]");
+      await adsCampaignCreate(project, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "campaign", "update"],
+    usage: "canonry ads campaign update <project> <campaign-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads campaign update <project> <campaign-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.campaign.update", usage);
+      const id = requirePositional(input, 1, { command: "ads.campaign.update", usage, message: "campaign id is required" });
+      await adsCampaignUpdate(project, id, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "campaign", "activate-tree"],
+    usage: "canonry ads campaign activate-tree <project> <campaign-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads campaign activate-tree <project> <campaign-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.campaign.activate-tree", usage);
+      const id = requirePositional(input, 1, {
+        command: "ads.campaign.activate-tree",
+        usage,
+        message: "campaign id is required"
+      });
+      await adsCampaignActivateTree(project, id, {
+        input: getString(input.values, "input"),
+        format: input.format
+      });
+    }
+  },
+  {
+    path: ["ads", "campaign", "pause"],
+    usage: "canonry ads campaign pause <project> <campaign-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads campaign pause <project> <campaign-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.campaign.pause", usage);
+      const id = requirePositional(input, 1, { command: "ads.campaign.pause", usage, message: "campaign id is required" });
+      await adsCampaignPause(project, id, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "ad-group", "create"],
+    usage: "canonry ads ad-group create <project> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const project = requireProject(input, "ads.ad-group.create", "canonry ads ad-group create <project> --input <json-file|-> [--format json]");
+      await adsAdGroupCreate(project, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "ad-group", "update"],
+    usage: "canonry ads ad-group update <project> <ad-group-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads ad-group update <project> <ad-group-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.ad-group.update", usage);
+      const id = requirePositional(input, 1, { command: "ads.ad-group.update", usage, message: "ad group id is required" });
+      await adsAdGroupUpdate(project, id, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "ad-group", "pause"],
+    usage: "canonry ads ad-group pause <project> <ad-group-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads ad-group pause <project> <ad-group-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.ad-group.pause", usage);
+      const id = requirePositional(input, 1, { command: "ads.ad-group.pause", usage, message: "ad group id is required" });
+      await adsAdGroupPause(project, id, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "ad", "create"],
+    usage: "canonry ads ad create <project> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const project = requireProject(input, "ads.ad.create", "canonry ads ad create <project> --input <json-file|-> [--format json]");
+      await adsAdCreate(project, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "ad", "update"],
+    usage: "canonry ads ad update <project> <ad-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads ad update <project> <ad-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.ad.update", usage);
+      const id = requirePositional(input, 1, { command: "ads.ad.update", usage, message: "ad id is required" });
+      await adsAdUpdate(project, id, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
+  {
+    path: ["ads", "ad", "pause"],
+    usage: "canonry ads ad pause <project> <ad-id> --input <json-file|-> [--format json]",
+    options: { input: stringOption() },
+    run: async (input) => {
+      const usage = "canonry ads ad pause <project> <ad-id> --input <json-file|-> [--format json]";
+      const project = requireProject(input, "ads.ad.pause", usage);
+      const id = requirePositional(input, 1, { command: "ads.ad.pause", usage, message: "ad id is required" });
+      await adsAdPause(project, id, { input: getString(input.values, "input"), format: input.format });
+    }
+  },
   {
     path: ["ads", "sync"],
     usage: "canonry ads sync <project> [--format json]",
@@ -2948,9 +3506,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs14 = await import("fs");
+    const fs15 = await import("fs");
     try {
-      const content = fs14.readFileSync(opts.keyFile, "utf-8");
+      const content = fs15.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -4297,9 +4855,9 @@ async function trafficConnectWordpress(project, opts) {
   }
   let applicationPassword = opts.appPassword?.trim() ?? "";
   if (!applicationPassword && opts.appPasswordFile) {
-    const fs14 = await import("fs");
+    const fs15 = await import("fs");
     try {
-      applicationPassword = fs14.readFileSync(opts.appPasswordFile, "utf-8").trim();
+      applicationPassword = fs15.readFileSync(opts.appPasswordFile, "utf-8").trim();
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       throw new CliError({
@@ -4355,10 +4913,10 @@ async function trafficConnectCloudRun(project, opts) {
       details: { project }
     });
   }
-  const fs14 = await import("fs");
+  const fs15 = await import("fs");
   let keyJson;
   try {
-    keyJson = fs14.readFileSync(opts.serviceAccountKey, "utf-8");
+    keyJson = fs15.readFileSync(opts.serviceAccountKey, "utf-8");
     JSON.parse(keyJson);
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -4418,9 +4976,9 @@ async function trafficConnectVercel(project, opts) {
   }
   let token = opts.token?.trim() ?? "";
   if (!token && opts.tokenFile) {
-    const fs14 = await import("fs");
+    const fs15 = await import("fs");
     try {
-      token = fs14.readFileSync(opts.tokenFile, "utf-8").trim();
+      token = fs15.readFileSync(opts.tokenFile, "utf-8").trim();
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       throw new CliError({
@@ -6238,7 +6796,7 @@ var KEYS_CLI_COMMANDS = [
 ];
 
 // src/commands/keyword.ts
-import fs3 from "fs";
+import fs4 from "fs";
 function getClient12() {
   return createApiClient();
 }
@@ -6306,7 +6864,7 @@ async function listKeywords(project, format) {
   }
 }
 async function importKeywords(project, filePath, format) {
-  if (!fs3.existsSync(filePath)) {
+  if (!fs4.existsSync(filePath)) {
     throw new CliError({
       code: "KEYWORD_IMPORT_FILE_NOT_FOUND",
       message: `File not found: ${filePath}`,
@@ -6317,7 +6875,7 @@ async function importKeywords(project, filePath, format) {
       }
     });
   }
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.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)) {
@@ -6518,7 +7076,7 @@ var KEYWORD_CLI_COMMANDS = [
 ];
 
 // src/commands/query.ts
-import fs4 from "fs";
+import fs5 from "fs";
 function getClient13() {
   return createApiClient();
 }
@@ -6609,7 +7167,7 @@ async function listQueries(project, format) {
   }
 }
 async function importQueries(project, filePath, format) {
-  if (!fs4.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     throw new CliError({
       code: "QUERY_IMPORT_FILE_NOT_FOUND",
       message: `File not found: ${filePath}`,
@@ -6620,7 +7178,7 @@ async function importQueries(project, filePath, format) {
       }
     });
   }
-  const content = fs4.readFileSync(filePath, "utf-8");
+  const content = fs5.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)) {
@@ -6822,7 +7380,7 @@ var QUERY_CLI_COMMANDS = [
 ];
 
 // src/commands/mcp.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path3 from "path";
 import { createRequire } from "module";
 
@@ -6938,8 +7496,8 @@ function renderClientSnippet(client, serverName, entry) {
   return renderJsonSnippet(serverName, entry, client.format);
 }
 function readJsonConfig(configPath) {
-  if (!fs5.existsSync(configPath)) return {};
-  const raw = fs5.readFileSync(configPath, "utf-8").trim();
+  if (!fs6.existsSync(configPath)) return {};
+  const raw = fs6.readFileSync(configPath, "utf-8").trim();
   if (!raw) return {};
   try {
     const parsed = JSON.parse(raw);
@@ -6957,14 +7515,14 @@ function readJsonConfig(configPath) {
   }
 }
 function writeJsonConfig(configPath, value) {
-  fs5.mkdirSync(path3.dirname(configPath), { recursive: true });
-  fs5.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
+  fs6.mkdirSync(path3.dirname(configPath), { recursive: true });
+  fs6.writeFileSync(configPath, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
 }
 function backupConfigIfPresent(configPath) {
-  if (!fs5.existsSync(configPath)) return void 0;
+  if (!fs6.existsSync(configPath)) return void 0;
   const backupPath = `${configPath}.canonry.bak`;
-  fs5.copyFileSync(configPath, backupPath);
+  fs6.copyFileSync(configPath, backupPath);
   return backupPath;
 }
 function findClientOrThrow(id) {
@@ -7318,13 +7876,13 @@ var NOTIFY_CLI_COMMANDS = [
 ];
 
 // src/commands/apply.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import { parseAllDocuments } from "yaml";
 async function applyConfigFile(filePath) {
-  if (!fs6.existsSync(filePath)) {
+  if (!fs7.existsSync(filePath)) {
     throw new Error(`File not found: ${filePath}`);
   }
-  const content = fs6.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   const docs = parseAllDocuments(content);
   const client = createApiClient();
   const errors = [];
@@ -7430,11 +7988,29 @@ async function showAnalytics(project, options) {
     console.log(JSON.stringify(results, null, 2));
   }
 }
+var BUCKET_DATE_WIDTH = 35;
+function bucketDates(bucket) {
+  const legacyCompatible = bucket;
+  const start = legacyCompatible.dataStartDate?.slice(0, 10);
+  const end = legacyCompatible.dataEndDate?.slice(0, 10);
+  if (!start || !end) return "date unavailable";
+  const sweeps = legacyCompatible.sweepCount ?? 1;
+  const pooled = sweeps > 1 ? ` (${sweeps} sweeps)` : "";
+  if (start === end) return `${start}${pooled}`;
+  return `${start} \u2192 ${end}${pooled}`;
+}
 function printMetrics(data) {
   console.log(`
 Citation Rate Trends (${data.window})`);
   console.log("\u2500".repeat(50));
   const pct4 = (n) => `${(n * 100).toFixed(1)}%`;
+  const modelChangeNotice = buildModelChangeNotice(readModelPointerChanges(data));
+  if (modelChangeNotice?.kind === "change") {
+    console.log(`
+  Model Updates Behind These Numbers:`);
+    console.log(`    ${modelChangeNotice.text}`);
+    console.log("");
+  }
   console.log(`  Overall: ${pct4(data.overall.citationRate)} (${data.overall.cited}/${data.overall.total})`);
   console.log(`  Trend:   ${data.trend}`);
   if (Object.keys(data.byProvider).length > 0) {
@@ -7446,28 +8022,95 @@ Citation Rate Trends (${data.window})`);
   }
   if (data.buckets.length > 0) {
     console.log(`
-  Timeline:`);
+  Timeline (dates in UTC):`);
     for (const bucket of data.buckets) {
-      const start = bucket.startDate.slice(0, 10);
       const bar = bucket.total > 0 ? "\u2588".repeat(Math.round(bucket.citationRate * 20)) : "";
-      console.log(`    ${start}  ${pct4(bucket.citationRate).padStart(6)}  ${bar}`);
+      console.log(`    ${bucketDates(bucket).padEnd(BUCKET_DATE_WIDTH)}  ${pct4(bucket.citationRate).padStart(6)}  ${bar}`);
     }
   }
   const providersInBuckets = [...new Set(data.buckets.flatMap((b) => Object.keys(b.byProvider ?? {})))].sort();
   if (data.buckets.length > 0 && providersInBuckets.length > 0) {
     console.log(`
-  By Provider Timeline:`);
+  By Provider Timeline (dates in UTC):`);
     for (const provider of providersInBuckets) {
       console.log(`    ${provider}:`);
       for (const bucket of data.buckets) {
         const metric = bucket.byProvider?.[provider];
         if (!metric) continue;
-        const start = bucket.startDate.slice(0, 10);
         const bar = metric.total > 0 ? "\u2588".repeat(Math.round(metric.citationRate * 20)) : "";
-        console.log(`      ${start}  ${pct4(metric.citationRate).padStart(6)}  ${bar}`);
+        console.log(`      ${bucketDates(bucket).padEnd(BUCKET_DATE_WIDTH)}  ${pct4(metric.citationRate).padStart(6)}  ${bar}`);
+      }
+    }
+  }
+  if (modelChangeNotice?.kind === "no-known-change") {
+    console.log(`
+  Model Updates Behind These Numbers:`);
+    console.log(`    ${modelChangeNotice.text}`);
+    console.log(`    ${modelChangeNotice.detail}`);
+  }
+  const attributionEntries = Object.entries(readModelAttribution(data)).sort(([a], [b]) => a.localeCompare(b));
+  if (attributionEntries.length > 0) {
+    console.log(`
+  Model Evidence:`);
+    for (const [provider, attribution] of attributionEntries) {
+      const latest = attribution.latestObservation;
+      console.log(`    ${provider}: latest ${formatModelEvidence(latest.state)} at ${latest.observedAt}`);
+      for (const event of attribution.events) {
+        const dating = event.fromPreWindowAnchor ? " (on or before)" : "";
+        const priorSweep = event.fromPreWindowAnchor && event.anchorObservedAt ? `  [last seen ${formatModelEvidence(event.from)} on ${event.anchorObservedAt}]` : "";
+        console.log(`      ${event.observedAt}${dating}  ${formatModelEvidence(event.from)} \u2192 ${formatModelEvidence(event.to)}${priorSweep}`);
+      }
+      const eventTotal = attribution.eventTotal ?? attribution.events.length;
+      if (eventTotal > attribution.events.length) {
+        console.log(`      Showing the latest ${attribution.events.length} of ${eventTotal} model changes.`);
+      }
+      if (attribution.anchorUnavailable) {
+        console.log(`      We did not look far enough back to be sure this is every change.`);
       }
     }
   }
+  const servedEntries = Object.entries(readServedModelAttribution(data)).sort(([a], [b]) => a.localeCompare(b));
+  if (servedEntries.length > 0) {
+    const mismatch = readModelServiceMismatch(data);
+    console.log(`
+  What the Engines Answered With:`);
+    for (const [provider, served] of servedEntries) {
+      const rawIds = served.latestServedModelIds.length > 0 ? served.latestServedModelIds.join(", ") : formatModelEvidence(served.latestObservation.state);
+      const substituted = mismatch[provider];
+      const note = substituted ? ` \u2014 not the ${formatModelEvidence(substituted.configured)} you selected` : "";
+      console.log(`    ${provider}: ${rawIds} at ${served.latestObservation.observedAt}${note}`);
+      for (const event of served.events) {
+        const dating = event.fromPreWindowAnchor ? " (on or before)" : "";
+        console.log(`      ${event.observedAt}${dating}  ${formatModelEvidence(event.from)} \u2192 ${formatModelEvidence(event.to)}`);
+      }
+    }
+  }
+}
+function readServedModelAttribution(data) {
+  const legacyCompatible = data;
+  return legacyCompatible.servedModelAttribution ?? {};
+}
+function readModelServiceMismatch(data) {
+  const legacyCompatible = data;
+  return legacyCompatible.modelServiceMismatch ?? {};
+}
+function readModelPointerChanges(data) {
+  const legacyCompatible = data;
+  return legacyCompatible.modelPointerChanges ?? {};
+}
+function readModelAttribution(data) {
+  const legacyCompatible = data;
+  return legacyCompatible.modelAttribution ?? {};
+}
+function formatModelEvidence(state) {
+  switch (state.status) {
+    case "known":
+      return `known ${state.model}`;
+    case "unknown":
+      return "unknown";
+    case "mixed":
+      return `mixed ${state.models.join(", ")}${state.includesUnknown ? " + unknown" : ""}`;
+  }
 }
 function printGaps(data) {
   console.log(`
@@ -7642,7 +8285,7 @@ async function loadLatestRunForExport(client, project) {
 }
 
 // src/commands/results-export.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path4 from "path";
 async function exportResults(project, opts) {
   const { output, ...request } = opts;
@@ -7652,8 +8295,8 @@ async function exportResults(project, opts) {
     return;
   }
   const target = output ? path4.resolve(output) : path4.resolve(process.cwd(), path4.basename(artifact.filename));
-  fs7.mkdirSync(path4.dirname(target), { recursive: true });
-  fs7.writeFileSync(target, artifact.content, "utf8");
+  fs8.mkdirSync(path4.dirname(target), { recursive: true });
+  fs8.writeFileSync(target, artifact.content, "utf8");
   console.log(`Results export written to ${target}`);
 }
 
@@ -7661,39 +8304,48 @@ async function exportResults(project, opts) {
 function getClient18() {
   return createApiClient();
 }
-async function showHistory(project, format) {
+function originLabel(entry) {
+  const userAgent = entry.userAgent?.toLowerCase() ?? "";
+  if (userAgent.includes("canonry-mcp")) return "mcp";
+  if (userAgent.includes("canonry-cli")) return "cli";
+  if (userAgent.includes("mozilla/")) return "dashboard";
+  return entry.actor;
+}
+async function showHistory(project, format, opts = {}) {
   const client = getClient18();
   try {
-    const entries = await client.getHistory(project);
+    const entries = project ? await client.getHistory(project, opts) : await client.getGlobalHistory(opts);
     if (format === "json") {
       console.log(JSON.stringify(entries, null, 2));
       return;
     }
     if (format === "jsonl") {
-      emitJsonl(entries.map((entry) => ({ project, ...entry })));
+      emitJsonl(entries.map((entry) => ({ project: project ?? null, ...entry })));
       return;
     }
     if (entries.length === 0) {
-      console.log(`No audit history for "${project}".`);
+      console.log(project ? `No audit history for "${project}".` : "No instance audit history.");
       return;
     }
-    console.log(`Audit history for "${project}" (${entries.length}):
+    console.log(`${project ? `Audit history for "${project}"` : "Instance audit history"} (${entries.length}):
 `);
-    console.log("  TIMESTAMP                ACTION              ENTITY TYPE  ACTOR");
-    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500");
+    console.log("  TIMESTAMP                ACTION              ENTITY TYPE  ORIGIN");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     for (const entry of entries) {
       console.log(
-        `  ${entry.createdAt.padEnd(23)}  ${entry.action.padEnd(18)}  ${entry.entityType.padEnd(11)}  ${entry.actor}`
+        `  ${entry.createdAt.padEnd(23)}  ${entry.action.padEnd(18)}  ${entry.entityType.padEnd(11)}  ${originLabel(entry)}`
       );
+      if (entry.actorSession) console.log(`    session: ${entry.actorSession}`);
+      if (entry.diff != null) console.log(`    diff: ${JSON.stringify(entry.diff)}`);
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new CliError({
       code: "HISTORY_FETCH_FAILED",
-      message: `Failed to fetch history for project "${project}"`,
+      message: project ? `Failed to fetch history for project "${project}"` : "Failed to fetch instance history",
       displayMessage: `Failed to fetch history: ${message}`,
       details: {
-        project,
+        project: project ?? null,
         cause: message
       }
     });
@@ -7809,10 +8461,25 @@ var OPERATOR_CLI_COMMANDS = [
   },
   {
     path: ["history"],
-    usage: "canonry history <project> [--format json]",
+    usage: "canonry history <project> [--limit <n>] [--since <ISO>] [--action <action>] [--actor <actor>] [--entity-type <type>] [--format json|jsonl]\n       canonry history --all [same filters]",
+    options: {
+      all: { type: "boolean", default: false },
+      limit: stringOption(),
+      since: stringOption(),
+      action: stringOption(),
+      actor: stringOption(),
+      "entity-type": stringOption()
+    },
     run: async (input) => {
-      const project = requireProject(input, "history", "canonry history <project> [--format json]");
-      await showHistory(project, input.format);
+      const usage = "canonry history <project> [--limit <n>] [--since <ISO>] [--action <action>] [--actor <actor>] [--entity-type <type>] [--format json|jsonl]\n       canonry history --all [same filters]";
+      const project = getBoolean(input.values, "all") ? void 0 : requireProject(input, "history", usage);
+      await showHistory(project, input.format, {
+        limit: parseIntegerOption(input, "limit", { command: "history", usage, message: "--limit must be an integer" }),
+        since: getString(input.values, "since"),
+        action: getString(input.values, "action"),
+        actor: getString(input.values, "actor"),
+        entityType: getString(input.values, "entity-type")
+      });
     }
   },
   {
@@ -7900,7 +8567,9 @@ async function createProject(name, opts) {
     ownedDomains: opts.ownedDomains ?? [],
     aliases: normalizeProjectAliases(opts.displayName, opts.aliases ?? []),
     country: opts.country,
-    language: opts.language
+    language: opts.language,
+    providers: opts.providers ?? [],
+    providerModels: opts.providerModels ?? {}
   });
   if (isMachineFormat(opts.format)) {
     console.log(JSON.stringify(result, null, 2));
@@ -7963,6 +8632,9 @@ async function showProject(name, format) {
   console.log(`  Language:         ${project.language}`);
   console.log(`  Config source:    ${project.configSource}`);
   console.log(`  Config revision:  ${project.configRevision}`);
+  console.log(`  Providers:        ${(project.providers ?? []).length > 0 ? project.providers.join(", ") : "all configured"}`);
+  const providerModels = Object.entries(project.providerModels ?? {});
+  console.log(`  Model overrides:  ${providerModels.length > 0 ? providerModels.map(([provider, model]) => `${provider}=${model}`).join(", ") : "(none; instance settings inherited)"}`);
   console.log(`  Tags:             ${project.tags.length > 0 ? project.tags.join(", ") : "(none)"}`);
   const labelEntries = Object.entries(project.labels);
   console.log(`  Labels:           ${labelEntries.length > 0 ? labelEntries.map(([k, v]) => `${k}=${v}`).join(", ") : "(none)"}`);
@@ -7992,19 +8664,45 @@ async function updateProjectSettings(name, opts) {
     const toRemove = new Set(opts.removeAlias.map((a) => a.toLowerCase()));
     aliases = aliases.filter((a) => !toRemove.has(a.toLowerCase()));
   }
+  const providerModels = { ...project.providerModels ?? {}, ...opts.providerModels ?? {} };
+  for (const provider of opts.clearProviderModels ?? []) delete providerModels[provider];
+  const nextProviders = opts.providers ?? project.providers ?? [];
+  if (nextProviders.length > 0) {
+    const requested = Object.keys(opts.providerModels ?? {}).filter((p) => !nextProviders.includes(p));
+    if (requested.length > 0) {
+      throw usageError(
+        `Error: --provider-model set for ${requested.join(", ")}, which ${requested.length > 1 ? "are" : "is"} not a selected engine for "${name}"`,
+        {
+          message: "provider-model set for a provider the project does not run",
+          details: { command: "project.update", project: name, providers: nextProviders, unselected: requested }
+        }
+      );
+    }
+  }
   const result = await client.putProject(name, {
     displayName: nextDisplayName,
     canonicalDomain: opts.domain ?? project.canonicalDomain,
     ownedDomains,
     aliases: normalizeProjectAliases(nextDisplayName, aliases),
     country: opts.country ?? project.country,
-    language: opts.language ?? project.language
+    language: opts.language ?? project.language,
+    tags: project.tags,
+    labels: project.labels,
+    providers: opts.providers ?? project.providers,
+    providerModels,
+    locations: project.locations,
+    defaultLocation: project.defaultLocation,
+    autoExtractBacklinks: project.autoExtractBacklinks
   });
   if (isMachineFormat(opts.format)) {
     console.log(JSON.stringify(result, null, 2));
     return;
   }
   console.log(`Project updated: ${result.name}`);
+  const dropped = Object.keys(providerModels).filter((provider) => !(provider in result.providerModels));
+  if (dropped.length > 0) {
+    console.log(`  Dropped model override for deselected engine(s): ${dropped.join(", ")}`);
+  }
 }
 async function deleteProject(name, opts) {
   const client = getClient20();
@@ -8108,20 +8806,22 @@ async function setDefaultLocation(project, label, format) {
 var PROJECT_CLI_COMMANDS = [
   {
     path: ["project", "create"],
-    usage: "canonry project create <name> [--domain <domain>] [--owned-domain <domain>...] [--alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--format json]",
+    usage: "canonry project create <name> [--domain <domain>] [--owned-domain <domain>...] [--alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--provider <name>...] [--provider-model provider=model...] [--format json]",
     options: {
       domain: { type: "string", short: "d" },
       "owned-domain": multiStringOption(),
       alias: multiStringOption(),
       country: stringOption(),
       language: stringOption(),
-      "display-name": stringOption()
+      "display-name": stringOption(),
+      provider: multiStringOption(),
+      "provider-model": multiStringOption()
     },
     run: async (input) => {
       const name = requireProject(
         input,
         "project.create",
-        "canonry project create <name> [--domain <domain>] [--owned-domain <domain>...] [--alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--format json]"
+        "canonry project create <name> [--domain <domain>] [--owned-domain <domain>...] [--alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--provider <name>...] [--provider-model provider=model...] [--format json]"
       );
       await createProject(name, {
         domain: getString(input.values, "domain") ?? name,
@@ -8130,13 +8830,15 @@ var PROJECT_CLI_COMMANDS = [
         country: getString(input.values, "country") ?? "US",
         language: getString(input.values, "language") ?? "en",
         displayName: getString(input.values, "display-name") ?? name,
+        providers: getStringArray(input.values, "provider") ?? [],
+        providerModels: parseProviderModelAssignments(getStringArray(input.values, "provider-model")),
         format: input.format
       });
     }
   },
   {
     path: ["project", "update"],
-    usage: "canonry project update <name> [--domain <domain>] [--owned-domain <domain>...] [--add-domain <domain>...] [--remove-domain <domain>...] [--alias <name>...] [--add-alias <name>...] [--remove-alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--format json]",
+    usage: "canonry project update <name> [--domain <domain>] [--owned-domain <domain>...] [--add-domain <domain>...] [--remove-domain <domain>...] [--alias <name>...] [--add-alias <name>...] [--remove-alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--provider <name>...] [--all-providers] [--provider-model provider=model...] [--clear-provider-model <provider>...] [--format json]",
     options: {
       domain: { type: "string", short: "d" },
       "owned-domain": multiStringOption(),
@@ -8147,14 +8849,26 @@ var PROJECT_CLI_COMMANDS = [
       "remove-alias": multiStringOption(),
       country: stringOption(),
       language: stringOption(),
-      "display-name": stringOption()
+      "display-name": stringOption(),
+      provider: multiStringOption(),
+      "all-providers": { type: "boolean" },
+      "provider-model": multiStringOption(),
+      "clear-provider-model": multiStringOption()
     },
     run: async (input) => {
       const name = requireProject(
         input,
         "project.update",
-        "canonry project update <name> [--domain <domain>] [--owned-domain <domain>...] [--add-domain <domain>...] [--remove-domain <domain>...] [--alias <name>...] [--add-alias <name>...] [--remove-alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--format json]"
+        "canonry project update <name> [--domain <domain>] [--owned-domain <domain>...] [--add-domain <domain>...] [--remove-domain <domain>...] [--alias <name>...] [--add-alias <name>...] [--remove-alias <name>...] [--country <code>] [--language <lang>] [--display-name <name>] [--provider <name>...] [--all-providers] [--provider-model provider=model...] [--clear-provider-model <provider>...] [--format json]"
       );
+      const providers = getStringArray(input.values, "provider");
+      const allProviders = getBoolean(input.values, "all-providers");
+      if (allProviders && providers?.length) throw usageError("Error: --all-providers conflicts with --provider");
+      const providerModels = parseProviderModelAssignments(getStringArray(input.values, "provider-model"));
+      const clearProviderModels = getStringArray(input.values, "clear-provider-model") ?? [];
+      for (const provider of clearProviderModels) {
+        if (provider in providerModels) throw usageError(`Error: --provider-model and --clear-provider-model conflict for ${provider}`);
+      }
       await updateProjectSettings(name, {
         displayName: getString(input.values, "display-name"),
         domain: getString(input.values, "domain"),
@@ -8166,6 +8880,9 @@ var PROJECT_CLI_COMMANDS = [
         removeAlias: getStringArray(input.values, "remove-alias"),
         country: getString(input.values, "country"),
         language: getString(input.values, "language"),
+        providers: allProviders ? [] : providers,
+        providerModels,
+        clearProviderModels,
         format: input.format
       });
     }
@@ -8281,9 +8998,21 @@ var PROJECT_CLI_COMMANDS = [
     }
   }
 ];
+function parseProviderModelAssignments(assignments) {
+  const result = {};
+  for (const assignment of assignments ?? []) {
+    const separator = assignment.indexOf("=");
+    const provider = separator === -1 ? "" : assignment.slice(0, separator).trim();
+    const model = separator === -1 ? "" : assignment.slice(separator + 1).trim();
+    if (!provider || !model) throw usageError(`Error: --provider-model must use provider=model (received ${assignment})`);
+    if (provider in result) throw usageError(`Error: duplicate --provider-model assignment for ${provider}`);
+    result[provider] = model;
+  }
+  return result;
+}
 
 // src/commands/report.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path5 from "path";
 function defaultOutputPath(project, audience) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -8300,10 +9029,10 @@ async function runReportCommand(project, opts = {}) {
   const html = renderReportHtml(report, { audience });
   const targetPath = opts.output ? path5.resolve(opts.output) : defaultOutputPath(project, audience);
   const dir = path5.dirname(targetPath);
-  if (!fs8.existsSync(dir)) {
-    fs8.mkdirSync(dir, { recursive: true });
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
-  fs8.writeFileSync(targetPath, html, "utf-8");
+  fs9.writeFileSync(targetPath, html, "utf-8");
   console.log(`Report written to ${targetPath}`);
 }
 
@@ -9168,11 +9897,11 @@ var SKILLS_CLI_COMMANDS = [
 ];
 
 // src/commands/snapshot.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path7 from "path";
 
 // src/snapshot-pdf.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path6 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
@@ -9386,8 +10115,8 @@ async function writeSnapshotPdf(report, outputPath) {
   renderQueries(pdf, report);
   const bytes = await doc.save();
   const resolvedPath = path6.resolve(outputPath);
-  fs9.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
-  fs9.writeFileSync(resolvedPath, bytes);
+  fs10.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
+  fs10.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -9546,8 +10275,8 @@ PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
   const resolvedPath = path7.resolve(outputPath);
-  fs10.mkdirSync(path7.dirname(resolvedPath), { recursive: true });
-  fs10.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  fs11.mkdirSync(path7.dirname(resolvedPath), { recursive: true });
+  fs11.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -10716,18 +11445,36 @@ async function bootstrapCommand(_opts) {
   } : existingConfig?.google;
   const keyHash = crypto.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
+  const existingConfigKeyHash = existingConfig ? crypto.createHash("sha256").update(existingConfig.apiKey).digest("hex") : void 0;
   const db = createClient(databasePath);
   migrate(db);
   db.transaction((tx) => {
-    tx.delete(apiKeys).where(eq(apiKeys.name, "default")).run();
-    tx.insert(apiKeys).values({
-      id: crypto.randomUUID(),
-      name: "default",
-      keyHash,
-      keyPrefix,
-      scopes: ["*"],
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).run();
+    const rotatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const existingDefaults = tx.select({ id: apiKeys.id, keyHash: apiKeys.keyHash }).from(apiKeys).where(eq(apiKeys.name, "default")).all();
+    const existingDefault = existingDefaults.find((key) => key.keyHash === existingConfigKeyHash) ?? existingDefaults.at(0);
+    if (existingDefault) {
+      tx.update(apiKeys).set({
+        keyHash,
+        keyPrefix,
+        scopes: ["*"],
+        projectId: null,
+        lastUsedAt: null,
+        revokedAt: null
+      }).where(eq(apiKeys.id, existingDefault.id)).run();
+      for (const duplicate of existingDefaults) {
+        if (duplicate.id === existingDefault.id) continue;
+        tx.update(apiKeys).set({ revokedAt: rotatedAt }).where(eq(apiKeys.id, duplicate.id)).run();
+      }
+    } else {
+      tx.insert(apiKeys).values({
+        id: crypto.randomUUID(),
+        name: "default",
+        keyHash,
+        keyPrefix,
+        scopes: ["*"],
+        createdAt: rotatedAt
+      }).run();
+    }
   });
   saveConfig({
     apiUrl: env.apiUrl || existingConfig?.apiUrl || `http://localhost:${process.env.CANONRY_PORT || "4100"}`,
@@ -10757,7 +11504,7 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs11 from "fs";
+import fs12 from "fs";
 import path9 from "path";
 function getPidPath() {
   return path9.join(getConfigDir(), "canonry.pid");
@@ -10800,8 +11547,8 @@ function buildServeForwardArgs(opts) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs11.existsSync(pidPath)) {
-    const existingPid = parseInt(fs11.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs12.existsSync(pidPath)) {
+    const existingPid = parseInt(fs12.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -10812,7 +11559,7 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs11.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
   }
   const cliPath = path9.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
@@ -10831,10 +11578,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs11.existsSync(configDir)) {
-    fs11.mkdirSync(configDir, { recursive: true });
+  if (!fs12.existsSync(configDir)) {
+    fs12.mkdirSync(configDir, { recursive: true });
   }
-  fs11.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs12.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (!isMachineFormat(format)) {
@@ -10843,7 +11590,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs11.unlinkSync(pidPath);
+      fs12.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -10875,7 +11622,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs11.existsSync(pidPath)) {
+  if (!fs12.existsSync(pidPath)) {
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
         stopped: false,
@@ -10886,7 +11633,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs11.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs12.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
@@ -10897,7 +11644,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs11.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -10911,12 +11658,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs11.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs11.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
         stopped: true,
@@ -10940,7 +11687,7 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs12 from "fs";
+import fs13 from "fs";
 import readline from "readline";
 import path10 from "path";
 function prompt(question) {
@@ -10964,7 +11711,7 @@ var PROJECT_MARKERS = [".git", "canonry.yaml", "canonry.yml", "package.json"];
 function cwdLooksLikeProject(dir) {
   const home = process.env.HOME ?? "";
   if (home && path10.resolve(dir) === path10.resolve(home)) return false;
-  return PROJECT_MARKERS.some((marker) => fs12.existsSync(path10.join(dir, marker)));
+  return PROJECT_MARKERS.some((marker) => fs13.existsSync(path10.join(dir, marker)));
 }
 var DEFAULT_AGENT_MODELS = {
   anthropic: "anthropic/claude-sonnet-4-6",
@@ -10995,8 +11742,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs12.existsSync(configDir)) {
-    fs12.mkdirSync(configDir, { recursive: true });
+  if (!fs13.existsSync(configDir)) {
+    fs13.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -11663,7 +12410,7 @@ function getClient25() {
 }
 async function technicalAeoScore(project, opts) {
   const client = getClient25();
-  const score = await client.getTechnicalAeoScore(project);
+  const score = await client.getTechnicalAeoScore(project, { runId: opts.runId });
   if (isMachineFormat(opts.format)) {
     console.log(JSON.stringify(score, null, 2));
     return;
@@ -11700,7 +12447,7 @@ async function technicalAeoScore(project, opts) {
 async function technicalAeoPages(project, opts) {
   const client = getClient25();
   const status = opts.status === "success" || opts.status === "error" ? opts.status : void 0;
-  const res = await client.getTechnicalAeoPages(project, { status, sort: opts.sort, limit: opts.limit });
+  const res = await client.getTechnicalAeoPages(project, { runId: opts.runId, status, sort: opts.sort, limit: opts.limit });
   if (opts.format === "jsonl") {
     emitJsonl(res.pages.map((p) => ({ project, runId: res.runId, ...p })));
     return;
@@ -11784,28 +12531,33 @@ async function technicalAeoRun(project, opts) {
 var TECHNICAL_AEO_CLI_COMMANDS = [
   {
     path: ["technical-aeo", "score"],
-    usage: "canonry technical-aeo score <project> [--format json]",
+    usage: "canonry technical-aeo score <project> [--run-id <id>] [--format json]",
+    options: {
+      "run-id": stringOption()
+    },
     run: async (input) => {
       const project = requireProject(
         input,
         "technical-aeo.score",
-        "canonry technical-aeo score <project> [--format json]"
+        "canonry technical-aeo score <project> [--run-id <id>] [--format json]"
       );
-      await technicalAeoScore(project, { format: input.format });
+      await technicalAeoScore(project, { runId: getString(input.values, "run-id"), format: input.format });
     }
   },
   {
     path: ["technical-aeo", "pages"],
-    usage: "canonry technical-aeo pages <project> [--status success|error] [--sort score-asc|score-desc|url] [--limit <n>] [--format json|jsonl]",
+    usage: "canonry technical-aeo pages <project> [--run-id <id>] [--status success|error] [--sort score-asc|score-desc|url] [--limit <n>] [--format json|jsonl]",
     options: {
+      "run-id": stringOption(),
       status: stringOption(),
       sort: stringOption(),
       limit: stringOption()
     },
     run: async (input) => {
-      const usage = "canonry technical-aeo pages <project> [--status success|error] [--sort score-asc|score-desc|url] [--limit <n>] [--format json|jsonl]";
+      const usage = "canonry technical-aeo pages <project> [--run-id <id>] [--status success|error] [--sort score-asc|score-desc|url] [--limit <n>] [--format json|jsonl]";
       const project = requireProject(input, "technical-aeo.pages", usage);
       await technicalAeoPages(project, {
+        runId: getString(input.values, "run-id"),
         status: getString(input.values, "status"),
         sort: getString(input.values, "sort"),
         limit: parseIntegerOption(input, "limit", {
@@ -12097,7 +12849,7 @@ var VISIBILITY_STATS_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs13 from "fs";
+import fs14 from "fs";
 
 // src/commands/wordpress.ts
 function getClient26() {
@@ -12336,12 +13088,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const path11 = await import("path");
   const filePath = path11.resolve(opts.from);
   let raw;
   try {
-    raw = await fs14.readFile(filePath, "utf8");
+    raw = await fs15.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -12438,13 +13190,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs14 = await import("fs/promises");
+  const fs15 = await import("fs/promises");
   const path11 = await import("path");
   const yaml = await loadYamlModule();
   const filePath = path11.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs14.readFile(filePath, "utf8");
+    raw = await fs15.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -12549,13 +13301,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs14 = await import("fs/promises");
+    const fs15 = await import("fs/promises");
     const path11 = await import("path");
     const yaml = await loadYamlModule();
     const filePath = path11.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs14.readFile(filePath, "utf8");
+      raw = await fs15.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -12704,7 +13456,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs13.readFileSync(contentFile, "utf-8");
+      return fs14.readFileSync(contentFile, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw usageError(`Error: could not read --content-file "${contentFile}": ${message}`, {