@canonry/canonry 4.117.1 → 4.118.0

package/dist/cli.js

@@ -29,7 +29,7 @@ import {
   setTelemetrySource,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-NY7SC4ES.js";
+} from "./chunk-HGNY5GL4.js";
 import {
   CliError,
   EXIT_SYSTEM_ERROR,
@@ -46,7 +46,7 @@ import {
   saveConfig,
   saveConfigPatch,
   usageError
-} from "./chunk-BMBHUFMI.js";
+} from "./chunk-75UBTCKS.js";
 import {
   apiKeys,
   createClient,
@@ -54,7 +54,7 @@ import {
   projects,
   queries,
   renderReportHtml
-} from "./chunk-V4SW7SVX.js";
+} from "./chunk-CMZIPFNQ.js";
 import {
   BacklinkSources,
   CcReleaseSyncStatuses,
@@ -65,6 +65,14 @@ import {
   REPORT_PERIOD_OPTIONS,
   RunStatuses,
   TrafficEventKinds,
+  adsAdCreateRequestSchema,
+  adsAdGroupCreateRequestSchema,
+  adsAdGroupUpdateRequestSchema,
+  adsAdUpdateRequestSchema,
+  adsCampaignCreateRequestSchema,
+  adsCampaignUpdateRequestSchema,
+  adsImageUploadRequestSchema,
+  adsPauseRequestSchema,
   backlinkSourceSchema,
   discoveryBucketSchema,
   discoveryCompetitorTypeSchema,
@@ -80,7 +88,7 @@ import {
   providerQuotaPolicySchema,
   resolveProviderInput,
   winnabilityClassSchema
-} from "./chunk-IAJ5TQ4S.js";
+} from "./chunk-KEZWLP4O.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
@@ -126,9 +134,9 @@ import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path10) {
-  if (args.length < path10.length) return false;
-  return path10.every((segment, index) => args[index] === segment);
+function matchesPath(args, path11) {
+  if (args.length < path11.length) return false;
+  return path11.every((segment, index) => args[index] === segment);
 }
 function withGlobalOptions(options) {
   const base = options ? { ...options } : {};
@@ -2713,9 +2721,46 @@ 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 printOperation(result, format) {
+  if (isMachineFormat(format)) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const operation = result.operation;
+  console.log(`${result.replayed ? "Replayed" : "Recorded"} ${operation.kind}: ${operation.state}`);
+  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 === "unknown") {
+    console.log("Do not retry with a new operation key. Reconcile this outcome with a human first.");
+  }
+}
 function describeConnection(status) {
   const lines = [];
   lines.push(`Connected:    ${status.connected ? "yes" : "no"}`);
@@ -2768,6 +2813,49 @@ async function adsStatus(project, opts) {
     console.log("Connect with: canonry ads connect " + project + " --api-key <sdk-key>");
   }
 }
+async function adsOperationGet(project, opts) {
+  printOperation(await getClient5().getAdsOperation(project, opts.operationKey), 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 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 +2973,122 @@ var ADS_CLI_COMMANDS = [
       await adsStatus(project, { 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", "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", "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 +3152,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs13 = await import("fs");
+    const fs15 = await import("fs");
     try {
-      const content = fs13.readFileSync(opts.keyFile, "utf-8");
+      const content = fs15.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -4202,9 +4406,9 @@ async function getCommand(opts) {
     console.log(JSON.stringify(leaf, null, 2));
   }
 }
-function walkPath(value, path10) {
-  if (!path10 || path10 === ".") return value;
-  const segments = path10.split(".").flatMap((part) => {
+function walkPath(value, path11) {
+  if (!path11 || path11 === ".") return value;
+  const segments = path11.split(".").flatMap((part) => {
     const tokens = [];
     let i = 0;
     const bracketStart = part.indexOf("[");
@@ -4252,13 +4456,13 @@ var GET_CLI_COMMANDS = [
     },
     run: async (input) => {
       const project = requireProject(input, "get", USAGE2);
-      const path10 = requirePositional(input, 1, {
+      const path11 = requirePositional(input, 1, {
         command: "get",
         usage: USAGE2,
         message: 'path is required (e.g. "scores.mentionShare.value")'
       });
       const from = getString(input.values, "from");
-      await getCommand({ project, path: path10, from, format: input.format });
+      await getCommand({ project, path: path11, from, format: input.format });
     }
   }
 ];
@@ -4297,9 +4501,9 @@ async function trafficConnectWordpress(project, opts) {
   }
   let applicationPassword = opts.appPassword?.trim() ?? "";
   if (!applicationPassword && opts.appPasswordFile) {
-    const fs13 = await import("fs");
+    const fs15 = await import("fs");
     try {
-      applicationPassword = fs13.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 +4559,10 @@ async function trafficConnectCloudRun(project, opts) {
       details: { project }
     });
   }
-  const fs13 = await import("fs");
+  const fs15 = await import("fs");
   let keyJson;
   try {
-    keyJson = fs13.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 +4622,9 @@ async function trafficConnectVercel(project, opts) {
   }
   let token = opts.token?.trim() ?? "";
   if (!token && opts.tokenFile) {
-    const fs13 = await import("fs");
+    const fs15 = await import("fs");
     try {
-      token = fs13.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 +6442,7 @@ var KEYS_CLI_COMMANDS = [
 ];
 
 // src/commands/keyword.ts
-import fs3 from "fs";
+import fs4 from "fs";
 function getClient12() {
   return createApiClient();
 }
@@ -6306,7 +6510,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 +6521,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 +6722,7 @@ var KEYWORD_CLI_COMMANDS = [
 ];
 
 // src/commands/query.ts
-import fs4 from "fs";
+import fs5 from "fs";
 function getClient13() {
   return createApiClient();
 }
@@ -6609,7 +6813,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 +6824,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 +7026,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 +7142,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 +7161,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 +7522,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 = [];
@@ -7641,43 +7845,68 @@ async function loadLatestRunForExport(client, project) {
   return client.getRun(latestRun.id);
 }
 
+// src/commands/results-export.ts
+import fs8 from "fs";
+import path4 from "path";
+async function exportResults(project, opts) {
+  const { output, ...request } = opts;
+  const artifact = await createApiClient().downloadResultsExport(project, request);
+  if (output === "-") {
+    process.stdout.write(artifact.content);
+    return;
+  }
+  const target = output ? path4.resolve(output) : path4.resolve(process.cwd(), path4.basename(artifact.filename));
+  fs8.mkdirSync(path4.dirname(target), { recursive: true });
+  fs8.writeFileSync(target, artifact.content, "utf8");
+  console.log(`Results export written to ${target}`);
+}
+
 // src/commands/history.ts
 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
       }
     });
@@ -7746,7 +7975,35 @@ async function getLatestRunSummary(client, project) {
 }
 
 // src/cli-commands/operator.ts
+var RESULTS_EXPORT_USAGE = "canonry results export <project> [--format json|csv] [--since <ISO>] [--until <ISO>] [--include-probes] [--output <path>|-]";
+function parseResultsExportFormat(value) {
+  if (value === void 0 || value === "json") return "json";
+  if (value === "csv") return "csv";
+  throw usageError(`Error: --format must be "json" or "csv"
+
+Usage: ${RESULTS_EXPORT_USAGE}`);
+}
 var OPERATOR_CLI_COMMANDS = [
+  {
+    path: ["results", "export"],
+    usage: RESULTS_EXPORT_USAGE,
+    options: {
+      since: stringOption(),
+      until: stringOption(),
+      "include-probes": { type: "boolean", default: false },
+      output: { type: "string", short: "o" }
+    },
+    run: async (input) => {
+      const project = requireProject(input, "results export", RESULTS_EXPORT_USAGE);
+      await exportResults(project, {
+        format: parseResultsExportFormat(getString(input.values, "format")),
+        since: getString(input.values, "since"),
+        until: getString(input.values, "until"),
+        includeProbes: getBoolean(input.values, "include-probes"),
+        output: getString(input.values, "output")
+      });
+    }
+  },
   {
     path: ["status"],
     usage: "canonry status <project> [--format json]",
@@ -7765,10 +8022,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")
+      });
     }
   },
   {
@@ -8239,11 +8511,11 @@ var PROJECT_CLI_COMMANDS = [
 ];
 
 // src/commands/report.ts
-import fs7 from "fs";
-import path4 from "path";
+import fs9 from "fs";
+import path5 from "path";
 function defaultOutputPath(project, audience) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  return path4.resolve(process.cwd(), `canonry-report-${project}-${audience}-${date}.html`);
+  return path5.resolve(process.cwd(), `canonry-report-${project}-${audience}-${date}.html`);
 }
 async function runReportCommand(project, opts = {}) {
   const client = createApiClient();
@@ -8254,12 +8526,12 @@ async function runReportCommand(project, opts = {}) {
     return;
   }
   const html = renderReportHtml(report, { audience });
-  const targetPath = opts.output ? path4.resolve(opts.output) : defaultOutputPath(project, audience);
-  const dir = path4.dirname(targetPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const targetPath = opts.output ? path5.resolve(opts.output) : defaultOutputPath(project, audience);
+  const dir = path5.dirname(targetPath);
+  if (!fs9.existsSync(dir)) {
+    fs9.mkdirSync(dir, { recursive: true });
   }
-  fs7.writeFileSync(targetPath, html, "utf-8");
+  fs9.writeFileSync(targetPath, html, "utf-8");
   console.log(`Report written to ${targetPath}`);
 }
 
@@ -9124,12 +9396,12 @@ var SKILLS_CLI_COMMANDS = [
 ];
 
 // src/commands/snapshot.ts
-import fs9 from "fs";
-import path6 from "path";
+import fs11 from "fs";
+import path7 from "path";
 
 // src/snapshot-pdf.ts
-import fs8 from "fs";
-import path5 from "path";
+import fs10 from "fs";
+import path6 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
 var PAGE_HEIGHT = 792;
@@ -9341,9 +9613,9 @@ async function writeSnapshotPdf(report, outputPath) {
   renderCompetitors(pdf, report);
   renderQueries(pdf, report);
   const bytes = await doc.save();
-  const resolvedPath = path5.resolve(outputPath);
-  fs8.mkdirSync(path5.dirname(resolvedPath), { recursive: true });
-  fs8.writeFileSync(resolvedPath, bytes);
+  const resolvedPath = path6.resolve(outputPath);
+  fs10.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
+  fs10.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -9501,9 +9773,9 @@ Markdown saved: ${savedMdPath}`);
 PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
-  const resolvedPath = path6.resolve(outputPath);
-  fs9.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
-  fs9.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  const resolvedPath = path7.resolve(outputPath);
+  fs11.mkdirSync(path7.dirname(resolvedPath), { recursive: true });
+  fs11.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -10486,7 +10758,7 @@ var CONTENT_CLI_COMMANDS = [
 
 // src/commands/bootstrap.ts
 import crypto from "crypto";
-import path7 from "path";
+import path8 from "path";
 import { eq } from "drizzle-orm";
 
 // ../config/src/index.ts
@@ -10643,7 +10915,7 @@ async function bootstrapCommand(_opts) {
     );
   }
   const configDir = getConfigDir();
-  const databasePath = env.databasePath || path7.join(configDir, "data.db");
+  const databasePath = env.databasePath || path8.join(configDir, "data.db");
   const existing = configExists();
   const existingConfig = existing ? loadConfig() : void 0;
   let rawApiKey;
@@ -10713,10 +10985,10 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs10 from "fs";
-import path8 from "path";
+import fs12 from "fs";
+import path9 from "path";
 function getPidPath() {
-  return path8.join(getConfigDir(), "canonry.pid");
+  return path9.join(getConfigDir(), "canonry.pid");
 }
 function isProcessAlive(pid) {
   try {
@@ -10756,8 +11028,8 @@ function buildServeForwardArgs(opts) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs10.existsSync(pidPath)) {
-    const existingPid = parseInt(fs10.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",
@@ -10768,9 +11040,9 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs10.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
   }
-  const cliPath = path8.resolve(new URL(import.meta.url).pathname);
+  const cliPath = path9.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
   const args = inSourceMode ? ["--import", "tsx", cliPath, "serve"] : [cliPath, "serve"];
   args.push(...buildServeForwardArgs(opts));
@@ -10787,10 +11059,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs10.existsSync(configDir)) {
-    fs10.mkdirSync(configDir, { recursive: true });
+  if (!fs12.existsSync(configDir)) {
+    fs12.mkdirSync(configDir, { recursive: true });
   }
-  fs10.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)) {
@@ -10799,7 +11071,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs10.unlinkSync(pidPath);
+      fs12.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -10831,7 +11103,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs10.existsSync(pidPath)) {
+  if (!fs12.existsSync(pidPath)) {
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
         stopped: false,
@@ -10842,7 +11114,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs10.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({
@@ -10853,7 +11125,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs10.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -10867,12 +11139,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs10.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs10.unlinkSync(pidPath);
+    fs12.unlinkSync(pidPath);
     if (isMachineFormat(format)) {
       console.log(JSON.stringify({
         stopped: true,
@@ -10896,9 +11168,9 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs11 from "fs";
+import fs13 from "fs";
 import readline from "readline";
-import path9 from "path";
+import path10 from "path";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -10919,8 +11191,8 @@ var DEFAULT_QUOTA = {
 var PROJECT_MARKERS = [".git", "canonry.yaml", "canonry.yml", "package.json"];
 function cwdLooksLikeProject(dir) {
   const home = process.env.HOME ?? "";
-  if (home && path9.resolve(dir) === path9.resolve(home)) return false;
-  return PROJECT_MARKERS.some((marker) => fs11.existsSync(path9.join(dir, marker)));
+  if (home && path10.resolve(dir) === path10.resolve(home)) return false;
+  return PROJECT_MARKERS.some((marker) => fs13.existsSync(path10.join(dir, marker)));
 }
 var DEFAULT_AGENT_MODELS = {
   anthropic: "anthropic/claude-sonnet-4-6",
@@ -10951,8 +11223,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs11.existsSync(configDir)) {
-    fs11.mkdirSync(configDir, { recursive: true });
+  if (!fs13.existsSync(configDir)) {
+    fs13.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -11067,7 +11339,7 @@ async function initCommand(opts) {
   const rawApiKey = `cnry_${crypto2.randomBytes(16).toString("hex")}`;
   const keyHash = crypto2.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
-  const databasePath = path9.join(configDir, "data.db");
+  const databasePath = path10.join(configDir, "data.db");
   const db = createClient(databasePath);
   migrate(db);
   db.insert(apiKeys).values({
@@ -11619,7 +11891,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;
@@ -11656,7 +11928,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;
@@ -11740,28 +12012,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", {
@@ -12053,7 +12330,7 @@ var VISIBILITY_STATS_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs12 from "fs";
+import fs14 from "fs";
 
 // src/commands/wordpress.ts
 function getClient26() {
@@ -12292,12 +12569,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs13 = await import("fs/promises");
-  const path10 = await import("path");
-  const filePath = path10.resolve(opts.from);
+  const fs15 = await import("fs/promises");
+  const path11 = await import("path");
+  const filePath = path11.resolve(opts.from);
   let raw;
   try {
-    raw = await fs13.readFile(filePath, "utf8");
+    raw = await fs15.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -12394,13 +12671,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs13 = await import("fs/promises");
-  const path10 = await import("path");
+  const fs15 = await import("fs/promises");
+  const path11 = await import("path");
   const yaml = await loadYamlModule();
-  const filePath = path10.resolve(opts.profile);
+  const filePath = path11.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs13.readFile(filePath, "utf8");
+    raw = await fs15.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -12505,13 +12782,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs13 = await import("fs/promises");
-    const path10 = await import("path");
+    const fs15 = await import("fs/promises");
+    const path11 = await import("path");
     const yaml = await loadYamlModule();
-    const filePath = path10.resolve(opts.profile);
+    const filePath = path11.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs13.readFile(filePath, "utf8");
+      raw = await fs15.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -12660,7 +12937,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs12.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}`, {