@ainyc/canonry 4.180.7 → 4.182.3

package/dist/{chunk-RXXZ5BU5.js → chunk-DY5ZDKQW.js}

@@ -78,6 +78,14 @@ function runInProgress(projectName) {
 function operationInProgress(message, details) {
   return new AppError("OPERATION_IN_PROGRESS", message, 409, details);
 }
+function scheduleVersionConflict(expectedUpdatedAt, actualUpdatedAt) {
+  return new AppError(
+    "SCHEDULE_VERSION_CONFLICT",
+    "The schedule changed since it was loaded. Reload it before saving.",
+    409,
+    { expectedUpdatedAt, actualUpdatedAt }
+  );
+}
 function measurementPlanRevisionConflict(expectedActiveRevision, actualActiveRevision) {
   return new AppError(
     "MEASUREMENT_PLAN_REVISION_CONFLICT",
@@ -6715,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
@@ -6818,6 +6842,8 @@ var measurementSetupResponseSchema = z15.object({
   state: measurementSetupStateSchema,
   nextAction: measurementSetupNextActionSchema,
   mode: measurementSetupModeSchema,
+  /** Whether this project's selected provider roster contains an engine the host can execute now. */
+  answerVisibilityProviderReady: z15.boolean(),
   activeRevision: measurementDraftRevisionSchema.nullable(),
   activeSchemaVersion: z15.union([z15.literal(1), z15.literal(2)]).nullable(),
   draft: z15.object({
@@ -10748,6 +10774,11 @@ var scheduleDtoSchema = z31.object({
   createdAt: z31.string(),
   updatedAt: z31.string()
 });
+var scheduleExpectedUpdatedAtSchema = z31.string().datetime();
+function nextScheduleUpdatedAt(previous, nowMs = Date.now()) {
+  const previousMs = previous === void 0 ? Number.NaN : Date.parse(previous);
+  return new Date(Number.isFinite(previousMs) ? Math.max(nowMs, previousMs + 1) : nowMs).toISOString();
+}
 var scheduleUpsertRequestSchema = z31.object({
   /** Run kind. Defaults to 'answer-visibility' so existing callers don't have to change. */
   kind: schedulableRunKindSchema.optional(),
@@ -10757,7 +10788,12 @@ var scheduleUpsertRequestSchema = z31.object({
   enabled: z31.boolean().optional().default(true),
   providers: z31.array(providerNameSchema).optional().default([]),
   /** Required when kind === 'traffic-sync'. Forbidden for other kinds. Validated server-side. */
-  sourceId: z31.string().optional()
+  sourceId: z31.string().optional(),
+  /**
+   * Optimistic concurrency guard. A timestamp updates only that exact version;
+   * null creates only while the schedule is absent. Omit for legacy behavior.
+   */
+  expectedUpdatedAt: scheduleExpectedUpdatedAtSchema.nullable().optional()
 }).refine(
   (data) => data.preset && !data.cron || !data.preset && data.cron,
   { message: 'Exactly one of "preset" or "cron" must be provided' }
@@ -11815,6 +11851,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);
@@ -16436,6 +16609,7 @@ export {
   noQueries,
   runInProgress,
   operationInProgress,
+  scheduleVersionConflict,
   measurementPlanRevisionConflict,
   measurementCompiledChecksumConflict,
   measurementRunRevisionMismatch,
@@ -16568,6 +16742,7 @@ export {
   measurementChangesResponseSchema,
   measurementDataQualityQuerySchema,
   measurementDataQualityResponseSchema,
+  measurementDraftCompetitorSchema,
   measurementDraftAuthoringSchema,
   MEASUREMENT_DRAFT_MAX_ASSIGNMENTS_PER_ACTION,
   MEASUREMENT_DRAFT_MAX_GROUPS,
@@ -16600,6 +16775,8 @@ export {
   measurementDraftUpsertGroupRequestSchema,
   measurementDraftRemoveGroupRequestSchema,
   measurementDraftUpsertCompetitorRequestSchema,
+  measurementDraftPinCompetitorRequestSchema,
+  measurementDraftPinCompetitorResponseSchema,
   measurementDraftRemoveCompetitorRequestSchema,
   measurementDraftCompilePreviewResponseSchema,
   measurementDraftDiffPreviewResponseSchema,
@@ -16854,6 +17031,8 @@ export {
   schedulableRunKindSchema,
   SchedulableRunKinds,
   scheduleDtoSchema,
+  scheduleExpectedUpdatedAtSchema,
+  nextScheduleUpdatedAt,
   scheduleUpsertRequestSchema,
   categorizeSource,
   categorizeSourceWithCompetitors,
@@ -16897,6 +17076,9 @@ export {
   modelIdsEquivalent,
   brandMetricsDtoSchema,
   sourceBreakdownDtoSchema,
+  competitorLandscapeQuerySchema,
+  COMPETITOR_LANDSCAPE_MODEL_GROUP_LIMIT,
+  competitorLandscapeResponseSchema,
   parseWindow,
   windowCutoff,
   resolveDateRange,

package/dist/{chunk-CWXPBQR5.js → chunk-FVC7PGYQ.js}

@@ -25,6 +25,7 @@ import {
   classifySkillFile,
   coerceSkillManifest,
   competitorBatchRequestSchema,
+  competitorLandscapeQuerySchema,
   describeError,
   discoveryBucketSchema,
   discoveryCompetitorTypeSchema,
@@ -92,7 +93,7 @@ import {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   trafficSeriesGranularitySchema
-} from "./chunk-RXXZ5BU5.js";
+} from "./chunk-DY5ZDKQW.js";
 
 // src/config.ts
 import fs from "fs";
@@ -160,8 +161,8 @@ function loadConfig() {
   if (!fs.existsSync(configPath)) {
     throw new Error(
       `Config not found at ${configPath}.
-Run "canonry init" to set up interactively, or "canonry init --gemini-key <key>" for non-interactive setup.
-For CI/Docker, use "canonry bootstrap" with env vars (GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, PERPLEXITY_API_KEY, GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET).`
+Run "canonry bootstrap" to create the local Page Health runtime; provider credentials are optional.
+Use "canonry init" instead only when you want interactive provider/OAuth provisioning.`
     );
   }
   const raw = fs.readFileSync(configPath, "utf-8");
@@ -174,8 +175,10 @@ For CI/Docker, use "canonry bootstrap" with env vars (GEMINI_API_KEY, OPENAI_API
     ].filter(Boolean).join(", ");
     throw new Error(
       `Invalid config at ${configPath} \u2014 missing: ${missing}.
-These fields are auto-generated. Run "canonry init" (or "canonry init --gemini-key <key>" for non-interactive setup) to create a valid config.
-Do not write config.yaml by hand; use "canonry init", "canonry settings", or "canonry bootstrap" instead.`
+Back up this config privately before you repair it.
+Restore the missing values from a known-good backup. If none exists, recover the original values before you retry.
+Keep the original API key and database path. Do not share secrets.
+Do not use "canonry init --force" for recovery. It replaces credentials without a backup.`
     );
   }
   if (parsed.geminiApiKey && !parsed.providers?.gemini) {
@@ -2396,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: [
@@ -6581,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({
@@ -9086,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
@@ -9478,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)",

package/dist/{chunk-XYTSKRO3.js → chunk-I3KSOMJA.js}

@@ -5,11 +5,11 @@ import {
   installSkills,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-CWXPBQR5.js";
+} from "./chunk-FVC7PGYQ.js";
 import {
   SKILL_MANIFEST_FILENAME,
   SkillsClients
-} from "./chunk-RXXZ5BU5.js";
+} from "./chunk-DY5ZDKQW.js";
 
 // src/skills-autosync.ts
 import fs from "fs";