@ainyc/canonry 4.180.8 → 4.183.0

package/dist/{chunk-GFVZOVG3.js → chunk-OF3PKBW4.js}

@@ -11,7 +11,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-IM4HFNGF.js";
+} from "./chunk-VFQPW2VX.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -157,7 +157,7 @@ import {
   siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-ZJ2VGTYU.js";
+} from "./chunk-ISONU3FA.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -296,7 +296,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-GN2G7VFK.js";
+} from "./chunk-Z2HTLTQV.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -11304,15 +11304,17 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         indexabilityVersion: crawlSummary.indexabilityRulesetVersion,
         linkScoreVersion: crawlSummary.linkScoreAlgorithmVersion,
         effectiveOptions: {
+          // Null, never absent: a reader must be able to tell "the operator set
+          // no edge budget and the engine derived one" from a missing field.
           mode: "summary",
           sitemapUrl: opts.sitemapUrl ?? null,
           maxPages,
-          maxEdges,
+          maxEdges: maxEdges ?? null,
           maxDepth: opts.maxDepth ?? null,
           checkDeadLinks: opts.checkDeadLinks ?? false
         },
         pageBudget: maxPages,
-        edgeBudget: maxEdges,
+        edgeBudget: maxEdges ?? null,
         maxDepth: opts.maxDepth ?? null,
         checkDeadLinks: opts.checkDeadLinks ?? false,
         complete: crawlSummary.complete,
@@ -11867,7 +11869,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-IURLYRB3.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-4XQBUFBU.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -13803,6 +13805,68 @@ function trimRowsToFit(rows, render) {
   }
   return kept;
 }
+function nestedArrayCandidates(root) {
+  const candidates = [];
+  const visit = (object) => {
+    let containsRecordCollection = false;
+    for (const [key, value] of Object.entries(object)) {
+      if (Array.isArray(value)) {
+        let hasNestedRecords = false;
+        let hasRecordRows = false;
+        for (const row of value) {
+          if (row && typeof row === "object" && !Array.isArray(row)) {
+            hasRecordRows = true;
+            hasNestedRecords = visit(row) || hasNestedRecords;
+          }
+        }
+        if (value.length > 0 && !hasNestedRecords) {
+          candidates.push({ owner: object, key, rows: value, size: serializeResult(value).length, hasRecordRows });
+        }
+        containsRecordCollection = hasRecordRows || hasNestedRecords || containsRecordCollection;
+      } else if (value && typeof value === "object") {
+        containsRecordCollection = visit(value) || containsRecordCollection;
+      }
+    }
+    return containsRecordCollection;
+  };
+  visit(root);
+  return candidates.sort(
+    (left, right) => Number(right.hasRecordRows) - Number(left.hasRecordRows) || right.size - left.size
+  );
+}
+function trimNestedArrays(full) {
+  const parsed = JSON.parse(full);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+  const copy = parsed;
+  copy.__truncated = true;
+  let out = serializeResult(copy);
+  while (out.length > MAX_TOOL_RESULT_CHARS) {
+    const candidate = nestedArrayCandidates(copy).at(0);
+    if (!candidate) return void 0;
+    const { owner, key, rows } = candidate;
+    const previous = owner.__omittedRowsByField;
+    const omitted = previous && typeof previous === "object" && !Array.isArray(previous) ? { ...previous } : {};
+    const priorCount = typeof omitted[key] === "number" ? omitted[key] : 0;
+    owner.__truncated = true;
+    owner.__omittedRowsByField = omitted;
+    const keep = (count2) => {
+      owner[key] = rows.slice(0, count2);
+      omitted[key] = priorCount + rows.length - count2;
+      return serializeResult(copy);
+    };
+    out = keep(0);
+    if (out.length > MAX_TOOL_RESULT_CHARS) continue;
+    let low = 0;
+    let high = rows.length - 1;
+    while (low < high) {
+      const middle = Math.ceil((low + high) / 2);
+      if (keep(middle).length <= MAX_TOOL_RESULT_CHARS) low = middle;
+      else high = middle - 1;
+    }
+    out = keep(low);
+  }
+  return out;
+}
 function truncateToolResult(details) {
   const full = serializeResult(details);
   if (full.length <= MAX_TOOL_RESULT_CHARS) return full;
@@ -13830,6 +13894,8 @@ function truncateToolResult(details) {
       });
       if (out.length <= MAX_TOOL_RESULT_CHARS) return out;
     }
+    const nested = trimNestedArrays(full);
+    if (nested !== void 0) return nested;
   }
   return full.slice(0, MAX_TOOL_RESULT_CHARS) + "\n" + TRUNCATION_NOTE;
 }

package/dist/{chunk-G7M2KM7Q.js → chunk-RQSSKN5F.js}

@@ -5,11 +5,11 @@ import {
   installSkills,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-IM4HFNGF.js";
+} from "./chunk-VFQPW2VX.js";
 import {
   SKILL_MANIFEST_FILENAME,
   SkillsClients
-} from "./chunk-GN2G7VFK.js";
+} from "./chunk-Z2HTLTQV.js";
 
 // src/skills-autosync.ts
 import fs from "fs";

package/dist/{chunk-IM4HFNGF.js → chunk-VFQPW2VX.js}

@@ -25,6 +25,7 @@ import {
   classifySkillFile,
   coerceSkillManifest,
   competitorBatchRequestSchema,
+  competitorLandscapeQuerySchema,
   describeError,
   discoveryBucketSchema,
   discoveryCompetitorTypeSchema,
@@ -92,7 +93,7 @@ import {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   trafficSeriesGranularitySchema
-} from "./chunk-GN2G7VFK.js";
+} from "./chunk-Z2HTLTQV.js";
 
 // src/config.ts
 import fs from "fs";
@@ -2398,6 +2399,18 @@ var postApiV1ProjectsByNameCompetitors = (options) => {
     }
   });
 };
+var getApiV1ProjectsByNameAnalyticsCompetitors = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/analytics/competitors",
+    ...options
+  });
+};
 var getApiV1ProjectsByNameRuns = (options) => {
   return (options.client ?? client).get({
     security: [
@@ -6583,6 +6596,16 @@ var ApiClient = class {
       })
     );
   }
+  /** Stored competitor SOV, optionally grouped or filtered by requested model; never starts provider work. */
+  async getCompetitorLandscape(project, opts = {}) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameAnalyticsCompetitors({
+        client: this.heyClient,
+        path: { name: project },
+        query: opts
+      })
+    );
+  }
   async getAnalyticsGaps(project, window) {
     return this.invoke(
       () => getApiV1ProjectsByNameAnalyticsGaps({
@@ -9088,6 +9111,9 @@ var competitorsInputSchema = z3.object({
   project: projectNameSchema,
   request: competitorBatchRequestSchema
 });
+var competitorLandscapeInputSchema = competitorLandscapeQuerySchema.safeExtend({
+  project: projectNameSchema
+}).strict();
 var projectUpsertInputSchema = z3.object({
   project: projectNameSchema,
   request: projectUpsertRequestSchema
@@ -9361,7 +9387,7 @@ var technicalAeoRunInputSchema = z3.object({
   sitemapUrl: z3.string().url().optional().describe("Override the sitemap URL. Defaults to https://<canonicalDomain>/sitemap.xml."),
   limit: z3.number().int().positive().max(2e3).optional().describe("Deprecated compatibility alias for maxPages."),
   maxPages: z3.number().int().positive().max(5e4).optional().describe("Maximum pages crawled and audited. Defaults to 1,000; hard maximum 50,000."),
-  maxEdges: z3.number().int().positive().max(1e6).optional().describe("Maximum link observations retained for this crawl. Defaults to 100,000; hard maximum 1,000,000."),
+  maxEdges: z3.number().int().positive().max(1e6).optional().describe("Maximum link observations retained for this crawl. When omitted the crawl engine derives the budget from the page count; hard maximum 1,000,000."),
   maxDepth: z3.number().int().min(0).max(100).optional().describe("Maximum internal-link depth from the root page."),
   checkDeadLinks: z3.boolean().optional().describe("Opt in to internal dead-link checks. Omitted and false both disable checks.")
 });
@@ -9480,6 +9506,20 @@ var canonryMcpTools = [
     openApiOperations: ["GET /api/v1/projects/{name}/analytics/sources"],
     handler: (client2, input) => client2.getAnalyticsSources(input.project, { window: input.window, limit: input.limit })
   }),
+  defineTool({
+    name: "canonry_competitor_landscape",
+    title: "Get historical competitor landscape",
+    description: "Returns pinned competitors first, then observed direct competitors and other cited sources from stored answer/source evidence only. Mention share is percentage points (0..100) from answer text; citations are independent. Share of voice needs ONE query class: `queryClass=all`, and omitting it, pool branded and non-brand, so every `shareOfVoice` comes back null and only the counts are published. Pass `queryClass=non-brand` (or `branded`) for a ratio, exactly as visibility-stats does. A project with no brand name or alias cannot be split by class, so a class-scoped read on one is refused rather than answered empty. Optional groupBy: model adds provider/requested-model groups with separate served-model evidence and sample counts. Optional model filters one exact requested model ID and requires provider. Unknown historical models remain explicit. Groups are not a matched-query or equal-weight comparison. Advanced reads support one market group or explicit scope: all-markets. No provider, discovery, or classifier work runs. Ranked lists are capped at 100 observed/other-source rows per group; pins remain complete. Model groups are capped at 50 and disclose truncation.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: competitorLandscapeInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/analytics/competitors"],
+    handler: (client2, input) => {
+      const { project, ...query } = input;
+      return client2.getCompetitorLandscape(project, query);
+    }
+  }),
   defineTool({
     name: "canonry_search",
     title: "Search project (composite)",
@@ -11405,7 +11445,7 @@ var canonryMcpTools = [
   defineTool({
     name: "canonry_technical_aeo_run",
     title: "Run Technical AEO site audit",
-    description: "Start a site-audit run. The run discovers root, sitemap, and linked pages. Its unattended default is 1,000 pages and 100,000 link observations; callers may explicitly raise either to its hard maximum. It returns {runId, status} and continues in the background. If an active run has identical effective options, this tool returns it; different options are refused. Poll canonry_run_get, then read the crawl and score tools.",
+    description: "Start a site-audit run. The run discovers root, sitemap, and linked pages. It defaults to 1,000 pages, and the engine derives the link-observation budget from that page count with a 100,000 floor, so raising maxPages raises it too. An explicit maxEdges is a ceiling that replaces the derivation and can sit below it. It returns {runId, status} and continues in the background. If an active run has identical effective options, this tool returns it; different options are refused. Poll canonry_run_get, then read the crawl and score tools.",
     access: "write",
     tier: "monitoring",
     inputSchema: technicalAeoRunInputSchema,

package/dist/{chunk-GN2G7VFK.js → chunk-Z2HTLTQV.js}

@@ -6723,6 +6723,22 @@ var measurementDraftUpsertCompetitorRequestSchema = z15.object({
   groupKey: measurementV2StableKeySchema,
   competitor: measurementDraftCompetitorSchema
 }).strict();
+var measurementDraftPinCompetitorRequestSchema = z15.object({
+  expectedActiveRevision: measurementDraftRevisionSchema,
+  groupKey: measurementV2StableKeySchema,
+  domain: z15.string().trim().min(1).refine((value) => hostOf(value) !== null, "A competitor domain must be a valid hostname"),
+  label: z15.string().trim().min(1).optional(),
+  aliases: z15.array(z15.string().trim().min(1)).optional()
+}).strict();
+var measurementDraftPinCompetitorResponseSchema = measurementDraftMutationResponseSchema.extend({
+  groupKey: measurementV2StableKeySchema,
+  competitor: measurementDraftCompetitorSchema,
+  draftCreated: z15.boolean(),
+  published: z15.object({
+    revision: measurementDraftRevisionSchema,
+    competitorsChanged: z15.literal(false)
+  }).strict()
+}).strict();
 var measurementDraftRemoveCompetitorRequestSchema = z15.object({
   groupKey: measurementV2StableKeySchema,
   competitorKey: measurementV2StableKeySchema
@@ -10627,7 +10643,6 @@ var siteCrawlDeadLinksResponseSchema = z30.discriminatedUnion("state", [
 ]);
 var SITE_AUDIT_DEFAULT_PAGE_LIMIT = 1e3;
 var SITE_AUDIT_MAX_PAGE_LIMIT = 5e4;
-var SITE_AUDIT_DEFAULT_EDGE_LIMIT = 1e5;
 var SITE_AUDIT_MAX_EDGE_LIMIT = 1e6;
 var siteAuditRunRequestSchema = z30.object({
   /** @deprecated Prefer the configured project sitemap; retained for compatibility. */
@@ -10636,7 +10651,7 @@ var siteAuditRunRequestSchema = z30.object({
   limit: z30.number().int().positive().max(2e3).optional(),
   /** Crawl page budget. When omitted, Canonry crawls up to 1,000 pages. */
   maxPages: z30.number().int().positive().max(5e4).optional(),
-  /** Internal-link observation budget. When omitted, Canonry retains up to 100,000 edges. */
+  /** Internal-link observation budget. When omitted, the crawl engine derives it from the page count. */
   maxEdges: z30.number().int().positive().max(1e6).optional(),
   /** Maximum crawl depth from the root. */
   maxDepth: z30.number().int().min(0).max(100).optional(),
@@ -10645,10 +10660,10 @@ var siteAuditRunRequestSchema = z30.object({
 });
 function normalizeSiteAuditRunRequest(request) {
   return {
-    schemaVersion: 1,
+    schemaVersion: 2,
     sitemapUrl: request.sitemapUrl ? new URL(request.sitemapUrl).toString() : null,
     maxPages: request.maxPages ?? request.limit ?? SITE_AUDIT_DEFAULT_PAGE_LIMIT,
-    maxEdges: request.maxEdges ?? SITE_AUDIT_DEFAULT_EDGE_LIMIT,
+    maxEdges: request.maxEdges ?? null,
     maxDepth: request.maxDepth ?? null,
     checkDeadLinks: request.checkDeadLinks === true
   };
@@ -11835,6 +11850,143 @@ var sourceBreakdownDtoSchema = z35.object({
   /** Applied ranked-list limit; null when the full list is returned. */
   limit: z35.number().int().nullable()
 });
+var competitorLandscapeSurfaceClassSchema = z35.enum([
+  "own",
+  "direct-competitor",
+  "ota-aggregator",
+  "editorial-media",
+  "other",
+  "unknown"
+]);
+var competitorLandscapeScopeSchema = z35.discriminatedUnion("kind", [
+  z35.object({ kind: z35.literal("project") }).strict(),
+  z35.object({ kind: z35.literal("group"), groupKey: z35.string().trim().min(1) }).strict(),
+  z35.object({ kind: z35.literal("all-markets") }).strict()
+]);
+var competitorLandscapeQueryClassSchema = z35.enum(["all", "branded", "non-brand"]);
+var competitorLandscapeModeSchema = z35.enum(["project", "all-markets"]);
+var competitorLandscapeQuerySchema = z35.object({
+  window: metricsWindowSchema.optional(),
+  groupKey: z35.string().trim().min(1).optional(),
+  scope: competitorLandscapeModeSchema.optional(),
+  provider: z35.string().trim().min(1).optional(),
+  /** Exact requested model ID; provider is required to disambiguate model names. */
+  model: modelIdSchema.optional(),
+  /** Opt-in agent comparison; the default landscape remains pooled. */
+  groupBy: z35.literal("model").optional(),
+  queryClass: competitorLandscapeQueryClassSchema.optional(),
+  location: z35.string().trim().min(1).optional(),
+  runId: z35.string().trim().min(1).optional()
+}).strict().superRefine((value, context) => {
+  if (value.scope === "all-markets" && value.groupKey !== void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["groupKey"],
+      message: "groupKey cannot be combined with scope=all-markets"
+    });
+  }
+  if (value.model !== void 0 && value.provider === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["provider"],
+      message: "provider is required when filtering by model"
+    });
+  }
+});
+var competitorLandscapeRowSchema = z35.object({
+  domain: z35.string().trim().min(1),
+  label: z35.string().trim().min(1),
+  surfaceClass: competitorLandscapeSurfaceClassSchema,
+  pinned: z35.boolean(),
+  /** One answer-text match at most per result. */
+  mentionCount: z35.number().int().nonnegative(),
+  /**
+   * Percentage points (0..100). Null outside the competitive denominator, and
+   * null for any selection that pools query classes: a brand wins its own
+   * branded queries by definition, so a pooled ratio flatters the project and
+   * buries every competitor. Counts stay populated either way.
+   */
+  shareOfVoice: z35.number().min(0).max(100).nullable(),
+  /** One source-list credit at most per result. Independent of mentions. */
+  citationCount: z35.number().int().nonnegative(),
+  /** Answer-text result count behind the mention field. */
+  answeredResults: z35.number().int().nonnegative(),
+  firstSeenAt: z35.string().datetime().nullable(),
+  lastSeenAt: z35.string().datetime().nullable(),
+  sampleUrls: z35.array(z35.string().url()).max(3)
+}).strict();
+var competitorLandscapeEvidenceSchema = z35.object({
+  answeredResults: z35.number().int().nonnegative(),
+  sourceResults: z35.number().int().nonnegative(),
+  missingAnswerTextResults: z35.number().int().nonnegative(),
+  /** Project plus direct-competitor named credits behind SOV. */
+  mentionCredits: z35.number().int().nonnegative(),
+  /** Citation captures that cannot prove a complete source list; never inferred as misses. */
+  incompleteSourceResults: z35.number().int().nonnegative(),
+  /** Stored probe snapshots intentionally omitted from every landscape metric. */
+  excludedProbeResults: z35.number().int().nonnegative(),
+  /** Stored snapshots from queued/running/failed/cancelled runs omitted from every metric. */
+  excludedNonCompletedResults: z35.number().int().nonnegative()
+}).strict();
+var COMPETITOR_LANDSCAPE_MODEL_GROUP_LIMIT = 50;
+var competitorLandscapeModelGroupSchema = z35.object({
+  provider: z35.string().trim().min(1),
+  /** Null preserves historical observations with unknown requested model identity. */
+  model: modelIdSchema.nullable(),
+  /** Raw upstream-reported identity; never filled from the requested model or current settings. */
+  servedModels: modelEvidenceStateSchema,
+  snapshotCount: z35.number().int().positive(),
+  project: competitorLandscapeRowSchema,
+  pinned: z35.array(competitorLandscapeRowSchema),
+  observed: z35.array(competitorLandscapeRowSchema),
+  otherSources: z35.array(competitorLandscapeRowSchema),
+  evidence: competitorLandscapeEvidenceSchema,
+  /** Per-group ranked-row truncation; all pins and full-population denominators remain included. */
+  truncated: z35.boolean()
+}).strict();
+var competitorLandscapeModelComparisonSchema = z35.object({
+  basis: z35.literal("requested-model"),
+  groups: z35.array(competitorLandscapeModelGroupSchema).max(COMPETITOR_LANDSCAPE_MODEL_GROUP_LIMIT),
+  totalGroups: z35.number().int().nonnegative(),
+  /** Groups sort by provider and requested model. Use provider/model filters to narrow a truncated result. */
+  truncated: z35.boolean()
+}).strict();
+var competitorLandscapeResponseSchema = z35.object({
+  window: metricsWindowSchema,
+  scope: competitorLandscapeScopeSchema,
+  project: competitorLandscapeRowSchema,
+  /** Explicit/custom competitors, preserved even with zero observations. */
+  pinned: z35.array(competitorLandscapeRowSchema),
+  /** Stored-discovery direct competitors, ordered by historical mention share. */
+  observed: z35.array(competitorLandscapeRowSchema),
+  /** Aggregators, editorial, unknown, and other cited sources; never share-of-voice competitors. */
+  otherSources: z35.array(competitorLandscapeRowSchema),
+  evidence: competitorLandscapeEvidenceSchema,
+  /** Present only when groupBy=model; pooled fields remain available and unchanged. */
+  modelComparison: competitorLandscapeModelComparisonSchema.optional(),
+  /** Present only for Advanced market reads; active metrics stay frozen while draft pins remain pending publish. */
+  marketState: z35.object({
+    activeRevision: z35.number().int().positive(),
+    draft: z35.object({
+      etag: z35.string().trim().min(1),
+      /** Draft-only market identities included in `pinned` for this response. */
+      pendingCompetitorDomains: z35.array(z35.string().trim().min(1))
+    }).strict().nullable()
+  }).strict().nullable(),
+  /** Echoes all applied filters so a client never mistakes a scoped reading for a project-wide one. */
+  filters: z35.object({
+    scope: competitorLandscapeModeSchema,
+    groupKey: z35.string().nullable(),
+    provider: z35.string().nullable(),
+    model: modelIdSchema.optional(),
+    groupBy: z35.literal("model").optional(),
+    queryClass: competitorLandscapeQueryClassSchema,
+    location: z35.string().nullable(),
+    runId: z35.string().nullable()
+  }).strict(),
+  /** True when ranked observed/source lists exceed the server cap; pinned rows are never dropped. */
+  truncated: z35.boolean()
+}).strict();
 function parseWindow(value) {
   if (value === void 0 || value === "") return "all";
   const parsed = metricsWindowSchema.safeParse(value);
@@ -16589,6 +16741,7 @@ export {
   measurementChangesResponseSchema,
   measurementDataQualityQuerySchema,
   measurementDataQualityResponseSchema,
+  measurementDraftCompetitorSchema,
   measurementDraftAuthoringSchema,
   MEASUREMENT_DRAFT_MAX_ASSIGNMENTS_PER_ACTION,
   MEASUREMENT_DRAFT_MAX_GROUPS,
@@ -16621,6 +16774,8 @@ export {
   measurementDraftUpsertGroupRequestSchema,
   measurementDraftRemoveGroupRequestSchema,
   measurementDraftUpsertCompetitorRequestSchema,
+  measurementDraftPinCompetitorRequestSchema,
+  measurementDraftPinCompetitorResponseSchema,
   measurementDraftRemoveCompetitorRequestSchema,
   measurementDraftCompilePreviewResponseSchema,
   measurementDraftDiffPreviewResponseSchema,
@@ -16920,6 +17075,9 @@ export {
   modelIdsEquivalent,
   brandMetricsDtoSchema,
   sourceBreakdownDtoSchema,
+  competitorLandscapeQuerySchema,
+  COMPETITOR_LANDSCAPE_MODEL_GROUP_LIMIT,
+  competitorLandscapeResponseSchema,
   parseWindow,
   windowCutoff,
   resolveDateRange,

package/dist/cli.js

@@ -28,11 +28,11 @@ import {
   trackCliCommandFinished,
   trackEvent,
   waitForServerRuntimeStartup
-} from "./chunk-GFVZOVG3.js";
+} from "./chunk-OF3PKBW4.js";
 import {
   autoSyncSkills,
   formatAutoSyncNotice
-} from "./chunk-G7M2KM7Q.js";
+} from "./chunk-RQSSKN5F.js";
 import {
   CliError,
   EXIT_SYSTEM_ERROR,
@@ -57,7 +57,7 @@ import {
   saveConfigPatch,
   systemError,
   usageError
-} from "./chunk-IM4HFNGF.js";
+} from "./chunk-VFQPW2VX.js";
 import {
   CLOUDFLARE_WORKER_BINDINGS,
   CLOUDFLARE_WORKER_GENERATED_MARKER,
@@ -71,7 +71,7 @@ import {
   projects,
   queries,
   renderReportHtml
-} from "./chunk-ZJ2VGTYU.js";
+} from "./chunk-ISONU3FA.js";
 import {
   AdsDeliverySnapshotStatuses,
   AdsHistoricalCampaignRollupStatuses,
@@ -140,7 +140,7 @@ import {
   providerQuotaPolicySchema,
   resolveProviderInput,
   winnabilityClassSchema
-} from "./chunk-GN2G7VFK.js";
+} from "./chunk-Z2HTLTQV.js";
 
 // src/cli.ts
 import { pathToFileURL } from "url";
@@ -7569,8 +7569,95 @@ async function listCompetitors(project, format) {
     console.log(`  ${c.domain}`);
   }
 }
+async function showCompetitorLandscape(project, options) {
+  const client = getClient10();
+  const data = await client.getCompetitorLandscape(project, {
+    window: options.window,
+    scope: options.scope,
+    groupKey: options.groupKey,
+    provider: options.provider,
+    ...options.groupBy ? { groupBy: options.groupBy } : {},
+    ...options.model !== void 0 ? { model: options.model } : {},
+    queryClass: options.queryClass,
+    location: options.location,
+    runId: options.runId
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (options.format === "jsonl") {
+    console.log(JSON.stringify(data));
+    return;
+  }
+  printCompetitorLandscape(data);
+}
+function printCompetitorLandscape(data) {
+  const scope = data.scope.kind === "group" ? `market ${data.scope.groupKey}` : data.scope.kind === "all-markets" ? "all markets" : "project";
+  console.log(`Competitor landscape \xB7 ${scope} \xB7 ${data.window}`);
+  if (data.filters.model !== void 0) {
+    console.log(`Requested model filter: ${data.filters.provider} \xB7 ${data.filters.model}`);
+  }
+  console.log("Mention share is answer-text evidence; citations are independent source-list evidence.");
+  console.log(
+    data.filters.queryClass === "all" ? "Share of voice is blank: branded and non-brand queries are pooled here. Add --query-class non-brand for a ratio." : `Counting ${data.filters.queryClass} queries only.`
+  );
+  if (data.truncated) console.log("Top 100 observed competitors and top 100 other cited sources shown; pinned competitors are complete.");
+  console.log("");
+  printLandscapeRows("Your brand", [data.project]);
+  printLandscapeRows("Pinned competitors", data.pinned);
+  printLandscapeRows("Observed competitors", data.observed);
+  printLandscapeRows("Other cited sources", data.otherSources);
+  console.log("");
+  console.log(
+    `Evidence: ${data.evidence.answeredResults} answer-text result(s), ${data.evidence.sourceResults} source result(s); excluded: ${data.evidence.excludedProbeResults} probe, ${data.evidence.excludedNonCompletedResults} non-completed.`
+  );
+  if (data.modelComparison) printModelComparison(data.modelComparison);
+}
+function describeServedModels(evidence) {
+  if (evidence.status === "unknown") return "Unknown (not disclosed)";
+  if (evidence.status === "known") return evidence.model;
+  return [...evidence.models, ...evidence.includesUnknown ? ["Unknown (not disclosed)"] : []].join(", ");
+}
+function printModelComparison(comparison) {
+  console.log("");
+  console.log(`Model comparison \xB7 requested-model basis \xB7 ${comparison.groups.length} of ${comparison.totalGroups} groups`);
+  console.log("Groups use stored observations. They do not form a matched-query or equal-weight comparison.");
+  if (comparison.truncated) console.log("The first 50 provider/model groups are shown. Additional groups are omitted.");
+  for (const group of comparison.groups) {
+    console.log("");
+    console.log(`${group.provider} \xB7 requested model: ${group.model ?? "Unknown (not recorded)"}`);
+    console.log(`Served model evidence: ${describeServedModels(group.servedModels)}`);
+    console.log(`Samples: ${group.snapshotCount} snapshot(s), ${group.evidence.answeredResults} answer-text result(s), ${group.evidence.sourceResults} source result(s).`);
+    printLandscapeRows("Your brand", [group.project], true);
+    printLandscapeRows("Pinned competitors", group.pinned, true);
+    printLandscapeRows("Observed competitors", group.observed, true);
+    printLandscapeRows("Other cited sources", group.otherSources, true);
+    if (group.truncated) console.log("Top 100 observed competitors and top 100 other sources shown. Pinned competitors are complete.");
+  }
+}
+function printLandscapeRows(heading, rows, showSampleCount = false) {
+  console.log(`${heading}:`);
+  if (rows.length === 0) {
+    console.log("  \u2014");
+    return;
+  }
+  for (const row of rows) {
+    const sov = row.shareOfVoice === null ? "\u2014" : `${row.shareOfVoice.toFixed(1)}%`;
+    console.log(`  ${row.domain}  mention ${row.mentionCount} \xB7 citation ${row.citationCount} \xB7 SOV ${sov}${showSampleCount ? ` \xB7 answers ${row.answeredResults}` : ""}`);
+  }
+}
 
 // src/cli-commands/competitor.ts
+var LANDSCAPE_USAGE = "canonry competitor landscape <project> [--window 7d|30d|90d|all] [--group-key <key>|--scope all-markets] [--by-model] [--provider <provider> [--model <id>]] [--query-class all|branded|non-brand] [--location <label>] [--run-id <id>] [--format json|jsonl]";
+function parseLandscapeScope(value) {
+  if (value === void 0 || value === "") return void 0;
+  if (value !== "all-markets") throw usageError(`--scope must be "all-markets" (got "${value}")`, {
+    message: '--scope must be "all-markets"',
+    details: { command: "competitor.landscape", usage: LANDSCAPE_USAGE }
+  });
+  return value;
+}
 var COMPETITOR_CLI_COMMANDS = [
   {
     path: ["competitor", "add"],
@@ -7634,14 +7721,60 @@ var COMPETITOR_CLI_COMMANDS = [
       await listCompetitors(project, input.format);
     }
   },
+  {
+    path: ["competitor", "landscape"],
+    usage: LANDSCAPE_USAGE,
+    options: {
+      window: stringOption(),
+      "group-key": stringOption(),
+      scope: stringOption(),
+      provider: stringOption(),
+      "by-model": { type: "boolean" },
+      model: stringOption(),
+      "query-class": stringOption(),
+      location: stringOption(),
+      "run-id": stringOption()
+    },
+    run: async (input) => {
+      const project = requireProject(input, "competitor.landscape", LANDSCAPE_USAGE);
+      const scope = parseLandscapeScope(getString(input.values, "scope"));
+      const groupKey = getString(input.values, "group-key");
+      const provider = getString(input.values, "provider");
+      const model = getString(input.values, "model");
+      if (model !== void 0 && !provider?.trim()) {
+        throw usageError("--model requires --provider", {
+          message: "--model requires --provider",
+          details: { command: "competitor.landscape", usage: LANDSCAPE_USAGE }
+        });
+      }
+      if (scope === "all-markets" && groupKey) {
+        throw usageError("--group-key cannot be combined with --scope all-markets", {
+          message: "--group-key cannot be combined with --scope all-markets",
+          details: { command: "competitor.landscape", usage: LANDSCAPE_USAGE }
+        });
+      }
+      await showCompetitorLandscape(project, {
+        window: getString(input.values, "window"),
+        groupKey,
+        scope,
+        provider,
+        ...getBoolean(input.values, "by-model") ? { groupBy: "model" } : {},
+        ...model !== void 0 ? { model } : {},
+        queryClass: getString(input.values, "query-class"),
+        location: getString(input.values, "location"),
+        runId: getString(input.values, "run-id"),
+        format: input.format
+      });
+    }
+  },
   {
     path: ["competitor"],
-    usage: "canonry competitor <add|remove|delete|list> <project> [args]",
+    usage: "canonry competitor <add|remove|delete|list|landscape> <project> [args]",
     run: async (input) => {
       unknownSubcommand(input.positionals[0], {
         command: "competitor",
-        usage: "canonry competitor <add|remove|delete|list> <project> [args]",
-        available: ["add", "remove", "delete", "list"]
+        usage: "canonry competitor <add|remove|delete|list|landscape> <project> [args]",
+        available: ["add", "remove", "delete", "list", "landscape"]
       });
     }
   }