@ainyc/canonry 2.14.2 → 2.16.0

package/dist/{chunk-7VWSR5F6.js → chunk-HNVRN5QL.js}

@@ -1310,10 +1310,14 @@ var ga4TrafficSummaryDtoSchema = z12.object({
     users: z12.number()
   })),
   aiReferrals: z12.array(ga4AiReferralDtoSchema),
-  /** Deduped AI session total: MAX(sessions) per date+source+medium across attribution dimensions, then summed. */
+  /** Deduped AI session total: MAX(sessions) per date+source+medium across attribution dimensions, then summed. Cross-cutting: can overlap with Direct/Organic/Social via firstUserSource. */
   aiSessionsDeduped: z12.number(),
   /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
   aiUsersDeduped: z12.number(),
+  /** AI sessions whose CURRENT sessionSource matched an AI engine. Disjoint from Direct/Organic/Social — safe for the channel breakdown. */
+  aiSessionsBySession: z12.number(),
+  /** AI users whose CURRENT sessionSource matched an AI engine. Disjoint from Direct/Organic/Social — safe for the channel breakdown. */
+  aiUsersBySession: z12.number(),
   socialReferrals: z12.array(ga4SocialReferralDtoSchema),
   /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
   socialSessions: z12.number(),
@@ -1321,8 +1325,10 @@ var ga4TrafficSummaryDtoSchema = z12.object({
   socialUsers: z12.number(),
   /** Organic sessions as a percentage of total sessions (0–100, rounded). */
   organicSharePct: z12.number(),
-  /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). */
+  /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). Cross-cutting: can overlap with Direct/Organic/Social. */
   aiSharePct: z12.number(),
+  /** Session-source-only AI sessions as a percentage of total sessions (0–100, rounded). Disjoint from Direct/Organic/Social. */
+  aiSharePctBySession: z12.number(),
   /** Direct-channel sessions as a percentage of total sessions (0–100, rounded). */
   directSharePct: z12.number(),
   /** Social sessions as a percentage of total sessions (0–100, rounded). */
@@ -1809,6 +1815,7 @@ var STRIP_KEYS = /* @__PURE__ */ new Set([
   "dclid",
   "gbraid",
   "wbraid",
+  "bingid",
   // Mailchimp
   "mc_cid",
   "mc_eid",
@@ -1817,7 +1824,16 @@ var STRIP_KEYS = /* @__PURE__ */ new Set([
   "_gl",
   // Google Tag Manager debug
   "gtm_latency",
-  "gtm_debug"
+  "gtm_debug",
+  // WordPress internal noise
+  "preview",
+  "preview_id",
+  "preview_nonce",
+  "_thumbnail_id",
+  // Common cache-busters/versioning
+  "v",
+  "ver",
+  "version"
 ]);
 function shouldStrip(key) {
   if (STRIP_KEYS.has(key)) return true;
@@ -1847,9 +1863,19 @@ function dropTrailingSlash(path2) {
 }
 function normalizeUrlPath(input) {
   if (input == null) return null;
-  const trimmed = input.trim();
+  let trimmed = input.trim();
   if (trimmed === "") return null;
+  trimmed = trimmed.replace(/ /g, " ").replace(/\s+/g, " ").trim();
+  if (trimmed === "" || trimmed === "/") return "/";
   if (trimmed === "(not set)") return null;
+  trimmed = trimmed.replace(/([a-zA-Z0-9])([).]+)$/, "$1");
+  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
+    trimmed = "/";
+  }
+  if (trimmed.includes(" ")) {
+    trimmed = trimmed.split(" ")[0];
+  }
+  if (trimmed === "" || trimmed === "/") return "/";
   let pathPart;
   let queryPart;
   if (/^https?:\/\//i.test(trimmed)) {
@@ -2543,6 +2569,901 @@ var ApiClient = class {
   }
 };
 
+// src/mcp/tool-registry.ts
+import { z as z19 } from "zod";
+
+// src/mcp/schema.ts
+import { z as z18 } from "zod";
+var projectNameSchema = z18.string().min(1).describe("Canonry project name.");
+var runIdSchema = z18.string().min(1).describe("Canonry run ID.");
+var insightIdSchema = z18.string().min(1).describe("Canonry insight ID.");
+var analyticsWindowSchema = z18.enum(["7d", "30d", "90d", "all"]).describe("Analytics time window.");
+var emptyInputSchema = z18.object({});
+var projectInputSchema = z18.object({
+  project: projectNameSchema
+});
+function toJsonSchema(schema, name) {
+  return {
+    ...z18.toJSONSchema(schema, { target: "draft-7" }),
+    title: name
+  };
+}
+function compactStringParams(values, keys) {
+  const params = {};
+  for (const key of keys) {
+    const value = values[key];
+    if (value === void 0 || value === null || value === "") continue;
+    params[key] = String(value);
+  }
+  return Object.keys(params).length ? params : void 0;
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    result.push(trimmed);
+  }
+  return result;
+}
+
+// src/mcp/tool-registry.ts
+var readAnnotations = (openWorldHint) => ({
+  readOnlyHint: true,
+  ...openWorldHint ? { openWorldHint } : {}
+});
+var writeAnnotations = (opts) => ({
+  readOnlyHint: false,
+  idempotentHint: opts.idempotentHint,
+  destructiveHint: Boolean(opts.destructiveHint),
+  ...opts.openWorldHint ? { openWorldHint: opts.openWorldHint } : {}
+});
+function defineTool(tool) {
+  return {
+    ...tool,
+    inputJsonSchema: toJsonSchema(tool.inputSchema, tool.name)
+  };
+}
+var runTriggerInputSchema = z19.object({
+  project: projectNameSchema,
+  request: runTriggerRequestSchema.optional()
+});
+var runsListInputSchema = z19.object({
+  project: projectNameSchema,
+  limit: z19.number().int().positive().max(500).optional()
+});
+var runGetInputSchema = z19.object({
+  runId: runIdSchema
+});
+var timelineInputSchema = z19.object({
+  project: projectNameSchema,
+  location: z19.string().optional().describe("Location label. Use an empty string for locationless results.")
+});
+var snapshotsListInputSchema = z19.object({
+  project: projectNameSchema,
+  limit: z19.number().int().positive().max(500).optional(),
+  offset: z19.number().int().nonnegative().optional(),
+  location: z19.string().optional().describe("Location label. Use an empty string for locationless results.")
+});
+var snapshotsDiffInputSchema = z19.object({
+  project: projectNameSchema,
+  run1: runIdSchema,
+  run2: runIdSchema
+});
+var insightsListInputSchema = z19.object({
+  project: projectNameSchema,
+  dismissed: z19.boolean().optional(),
+  runId: runIdSchema.optional()
+});
+var insightInputSchema = z19.object({
+  project: projectNameSchema,
+  insightId: insightIdSchema
+});
+var healthHistoryInputSchema = z19.object({
+  project: projectNameSchema,
+  limit: z19.number().int().positive().max(100).optional()
+});
+var gscPerformanceInputSchema = z19.object({
+  project: projectNameSchema,
+  startDate: z19.string().optional(),
+  endDate: z19.string().optional(),
+  query: z19.string().optional(),
+  page: z19.string().optional(),
+  limit: z19.number().int().positive().max(500).optional(),
+  window: analyticsWindowSchema.optional()
+});
+var gscInspectionsInputSchema = z19.object({
+  project: projectNameSchema,
+  url: z19.string().optional(),
+  limit: z19.number().int().positive().max(500).optional()
+});
+var gscCoverageHistoryInputSchema = z19.object({
+  project: projectNameSchema,
+  limit: z19.number().int().positive().max(500).optional()
+});
+var gaWindowInputSchema = z19.object({
+  project: projectNameSchema,
+  window: analyticsWindowSchema.optional()
+});
+var gaTrafficInputSchema = gaWindowInputSchema.extend({
+  limit: z19.number().int().positive().max(500).optional()
+});
+var keywordsInputSchema = z19.object({
+  project: projectNameSchema,
+  request: keywordBatchRequestSchema
+});
+var keywordGenerateInputSchema = z19.object({
+  project: projectNameSchema,
+  request: keywordGenerateRequestSchema
+});
+var competitorsInputSchema = z19.object({
+  project: projectNameSchema,
+  request: competitorBatchRequestSchema
+});
+var projectUpsertInputSchema = z19.object({
+  project: projectNameSchema,
+  request: projectUpsertRequestSchema
+});
+var applyConfigInputSchema = z19.object({
+  config: projectConfigSchema
+});
+var scheduleSetInputSchema = z19.object({
+  project: projectNameSchema,
+  schedule: scheduleUpsertRequestSchema
+});
+var agentWebhookAttachInputSchema = z19.object({
+  project: projectNameSchema,
+  url: z19.string().url()
+});
+var doctorInputSchema = z19.object({
+  project: projectNameSchema.optional().describe("Project name to scope project-level checks. Omit to run global checks (provider keys, config, etc.)."),
+  checks: z19.array(z19.string().min(1)).optional().describe('Optional check IDs or wildcard prefixes (e.g. "google.auth.*", "config.providers"). Empty/omitted runs all matching checks for the chosen scope.')
+});
+var contentTargetsInputSchema = z19.object({
+  project: projectNameSchema,
+  limit: z19.number().int().positive().max(500).optional().describe("Max rows. Defaults to all. Use a small number (3-10) when summarizing for the user."),
+  includeInProgress: z19.boolean().optional().describe("Include rows that already have an in-flight tracked action. Default false.")
+});
+var backlinksDomainsInputSchema = z19.object({
+  project: projectNameSchema,
+  limit: z19.number().int().positive().max(200).optional().describe("Max linking-domain rows. Default 50, max 200."),
+  release: z19.string().optional().describe("Common Crawl release id (e.g., cc-main-2026-jan-feb-mar). Omit for the most recent release with data.")
+});
+var memoryUpsertInputSchema = z19.object({
+  project: projectNameSchema,
+  key: z19.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH).describe(`Stable identifier for the note (max ${AGENT_MEMORY_KEY_MAX_LENGTH} chars). Writing the same key overwrites the prior value.`),
+  value: z19.string().min(1).describe(`Plain-text note body (max ${AGENT_MEMORY_VALUE_MAX_BYTES} bytes). Use for durable operator preferences, migration context, or non-obvious reasoning that should survive future sessions.`)
+});
+var memoryForgetInputSchema = z19.object({
+  project: projectNameSchema,
+  key: z19.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH).describe("Exact key of the note to remove. No-op (status=missing) when no note exists for that key.")
+});
+var AGENT_WEBHOOK_EVENTS = [
+  notificationEventSchema.enum["run.completed"],
+  notificationEventSchema.enum["insight.critical"],
+  notificationEventSchema.enum["insight.high"],
+  notificationEventSchema.enum["citation.gained"]
+];
+var canonryMcpTools = [
+  defineTool({
+    name: "canonry_projects_list",
+    title: "List Canonry projects",
+    description: "List all Canonry projects available through the configured API.",
+    access: "read",
+    tier: "core",
+    inputSchema: emptyInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects"],
+    handler: (client) => client.listProjects()
+  }),
+  defineTool({
+    name: "canonry_project_get",
+    title: "Get project",
+    description: "Get a Canonry project by name.",
+    access: "read",
+    tier: "core",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}"],
+    handler: (client, input) => client.getProject(input.project)
+  }),
+  defineTool({
+    name: "canonry_project_overview",
+    title: "Get project overview (composite)",
+    description: 'One-call summary for "how is project X doing?" \u2014 bundles project info, latest run, top undismissed insights, latest health snapshot, keyword cited rate, per-provider breakdown, and gained/lost/emerging vs the previous run. Prefer this over fanning out to separate tools.',
+    access: "read",
+    tier: "core",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/overview"],
+    handler: (client, input) => client.getProjectOverview(input.project)
+  }),
+  defineTool({
+    name: "canonry_search",
+    title: "Search project (composite)",
+    description: "Search query snapshots and intelligence insights for the given text. Looks at snapshot answer text, cited domains, raw provider responses, and insight title/keyword/recommendation/cause. Returns ranked hits with snippets \u2014 use it instead of paginating snapshots when you need to find a competitor mention or term.",
+    access: "read",
+    tier: "core",
+    inputSchema: z19.object({
+      project: projectNameSchema,
+      q: z19.string().min(2).describe("Search term, at least 2 characters."),
+      limit: z19.number().int().positive().max(50).optional().describe("Max combined hits (1-50, default 25).")
+    }),
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/search"],
+    handler: (client, input) => client.searchProject(input.project, { q: input.q, limit: input.limit })
+  }),
+  defineTool({
+    name: "canonry_doctor",
+    title: "Run health checks",
+    description: 'Run canonry health checks. With `project`, runs project-scoped checks (Google/GA auth, redirect URI, scopes, property access). Without `project`, runs global checks (provider keys, etc.). Use `checks` to filter by exact ID or wildcard prefix (e.g. ["google.auth.*"]). Returns a structured DoctorReport with per-check status, code, summary, remediation, and details \u2014 use this to diagnose Google auth failures (401/403/redirect-mismatch/principal-mismatch) without parsing logs.',
+    access: "read",
+    tier: "core",
+    inputSchema: doctorInputSchema,
+    annotations: readAnnotations(true),
+    openApiOperations: ["GET /api/v1/doctor", "GET /api/v1/projects/{name}/doctor"],
+    handler: (client, input) => client.runDoctor({ project: input.project, checkIds: input.checks })
+  }),
+  defineTool({
+    name: "canonry_project_export",
+    title: "Export project config",
+    description: "Export a Canonry project in config-as-code format.",
+    access: "read",
+    tier: "setup",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/export"],
+    handler: (client, input) => client.getExport(input.project)
+  }),
+  defineTool({
+    name: "canonry_project_history",
+    title: "Get project history",
+    description: "Get audit history for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/history"],
+    handler: (client, input) => client.getHistory(input.project)
+  }),
+  defineTool({
+    name: "canonry_runs_list",
+    title: "List project runs",
+    description: "List runs for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: runsListInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/runs"],
+    handler: (client, input) => client.listRuns(input.project, input.limit)
+  }),
+  defineTool({
+    name: "canonry_runs_latest",
+    title: "Get latest project run",
+    description: "Get the latest run and total run count for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/runs/latest"],
+    handler: (client, input) => client.getLatestRun(input.project)
+  }),
+  defineTool({
+    name: "canonry_run_get",
+    title: "Get run",
+    description: "Get a Canonry run with its snapshots.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: runGetInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/runs/{id}"],
+    handler: (client, input) => client.getRun(input.runId)
+  }),
+  defineTool({
+    name: "canonry_timeline_get",
+    title: "Get project timeline",
+    description: "Get per-keyword citation history for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: timelineInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/timeline"],
+    handler: (client, input) => client.getTimeline(input.project, input.location)
+  }),
+  defineTool({
+    name: "canonry_snapshots_list",
+    title: "List query snapshots",
+    description: "List paginated query snapshots for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: snapshotsListInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/snapshots"],
+    handler: (client, input) => client.getSnapshots(input.project, {
+      limit: input.limit,
+      offset: input.offset,
+      location: input.location
+    })
+  }),
+  defineTool({
+    name: "canonry_snapshots_diff",
+    title: "Diff snapshots",
+    description: "Compare query snapshot states between two Canonry runs.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: snapshotsDiffInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/snapshots/diff"],
+    handler: (client, input) => client.getSnapshotDiff(input.project, input.run1, input.run2)
+  }),
+  defineTool({
+    name: "canonry_insights_list",
+    title: "List insights",
+    description: "List intelligence insights for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: insightsListInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/insights"],
+    handler: (client, input) => client.getInsights(input.project, { dismissed: input.dismissed, runId: input.runId })
+  }),
+  defineTool({
+    name: "canonry_insight_get",
+    title: "Get insight",
+    description: "Get one intelligence insight for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: insightInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/insights/{id}"],
+    handler: (client, input) => client.getInsight(input.project, input.insightId)
+  }),
+  defineTool({
+    name: "canonry_health_latest",
+    title: "Get latest health",
+    description: 'Get the latest health snapshot for a Canonry project. Always returns a snapshot once the project exists: real data carries `status: "ready"`; newly-created projects (or projects with only failed runs) carry `status: "no-data"` with `reason: "no-runs-yet"` and zeroed metrics.',
+    access: "read",
+    tier: "monitoring",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/health/latest"],
+    handler: (client, input) => client.getHealth(input.project)
+  }),
+  defineTool({
+    name: "canonry_health_history",
+    title: "Get health history",
+    description: "Get health snapshot history for a Canonry project.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: healthHistoryInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/health/history"],
+    handler: (client, input) => client.getHealthHistory(input.project, input.limit)
+  }),
+  defineTool({
+    name: "canonry_content_targets",
+    title: "Get content targets",
+    description: "Ranked, action-typed content opportunities. Each row is `{query, action \u2208 create|expand|refresh|add-schema, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence}`. Use this to recommend which post the user should write or refresh next.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: contentTargetsInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/content/targets"],
+    handler: (client, input) => client.getContentTargets(input.project, {
+      limit: input.limit,
+      includeInProgress: input.includeInProgress
+    })
+  }),
+  defineTool({
+    name: "canonry_content_sources",
+    title: "Get grounding sources",
+    description: "URL-level competitive grounding-source map. Per query, lists every URL the LLM cited (our domain vs competitors) with citation count and providers. Read this to understand which specific competitor URL is winning a query.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/content/sources"],
+    handler: (client, input) => client.getContentSources(input.project)
+  }),
+  defineTool({
+    name: "canonry_content_gaps",
+    title: "Get content gaps",
+    description: 'Queries where competitors are cited but our domain is not, ranked by miss rate. The blunt-instrument view of "what competitors are winning that we are not." Use canonry_content_targets for action-typed recommendations on the same data.',
+    access: "read",
+    tier: "monitoring",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/content/gaps"],
+    handler: (client, input) => client.getContentGaps(input.project)
+  }),
+  defineTool({
+    name: "canonry_keywords_list",
+    title: "List keywords",
+    description: "List tracked keywords for a Canonry project.",
+    access: "read",
+    tier: "setup",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/keywords"],
+    handler: (client, input) => client.listKeywords(input.project)
+  }),
+  defineTool({
+    name: "canonry_competitors_list",
+    title: "List competitors",
+    description: "List tracked competitors for a Canonry project.",
+    access: "read",
+    tier: "setup",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/competitors"],
+    handler: (client, input) => client.listCompetitors(input.project)
+  }),
+  defineTool({
+    name: "canonry_schedule_get",
+    title: "Get schedule",
+    description: "Get the scheduled run configuration for a Canonry project.",
+    access: "read",
+    tier: "setup",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/schedule"],
+    handler: (client, input) => client.getSchedule(input.project)
+  }),
+  defineTool({
+    name: "canonry_backlinks_latest_release",
+    title: "Discover latest Common Crawl release",
+    description: "Probes Common Crawl to find the latest published hyperlinkgraph release. Returns the release id and file URLs/sizes ready to feed into a backlinks sync (or null if no candidate slug responded).",
+    access: "read",
+    tier: "setup",
+    inputSchema: emptyInputSchema,
+    annotations: readAnnotations(true),
+    openApiOperations: ["GET /api/v1/backlinks/latest-release"],
+    handler: (client) => client.backlinksLatestRelease()
+  }),
+  defineTool({
+    name: "canonry_backlinks_domains",
+    title: "List backlink domains",
+    description: "Backlink summary and top linking domains from the most recent ready Common Crawl release for a project. Off-site authority signal that correlates with citation likelihood. Returns null summary when no release sync has completed for this workspace.",
+    access: "read",
+    tier: "setup",
+    inputSchema: backlinksDomainsInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/backlinks/domains"],
+    handler: (client, input) => client.backlinksDomains(input.project, {
+      limit: input.limit ?? 50,
+      release: input.release
+    })
+  }),
+  defineTool({
+    name: "canonry_settings_get",
+    title: "Get settings",
+    description: "Get Canonry API settings and configured provider status.",
+    access: "read",
+    tier: "core",
+    inputSchema: emptyInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/settings"],
+    handler: (client) => client.getSettings()
+  }),
+  defineTool({
+    name: "canonry_google_connections_list",
+    title: "List Google connections",
+    description: "List configured Google connections for a Canonry project.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/connections"],
+    handler: (client, input) => client.googleConnections(input.project)
+  }),
+  defineTool({
+    name: "canonry_gsc_performance",
+    title: "Get GSC performance",
+    description: "Get stored Google Search Console performance rows for a Canonry project.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: gscPerformanceInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/performance"],
+    handler: (client, input) => client.gscPerformance(input.project, compactStringParams(input, ["startDate", "endDate", "query", "page", "limit", "window"]))
+  }),
+  defineTool({
+    name: "canonry_gsc_inspections",
+    title: "List GSC inspections",
+    description: "List stored URL inspection rows for a Canonry project.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: gscInspectionsInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/inspections"],
+    handler: (client, input) => client.gscInspections(input.project, compactStringParams(input, ["url", "limit"]))
+  }),
+  defineTool({
+    name: "canonry_gsc_deindexed",
+    title: "List deindexed GSC URLs",
+    description: "List URLs that appear to have become deindexed in Google Search Console data.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/deindexed"],
+    handler: (client, input) => client.gscDeindexed(input.project)
+  }),
+  defineTool({
+    name: "canonry_gsc_coverage",
+    title: "Get GSC coverage",
+    description: "Get Google Search Console coverage summary for a Canonry project.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/coverage"],
+    handler: (client, input) => client.gscCoverage(input.project)
+  }),
+  defineTool({
+    name: "canonry_gsc_coverage_history",
+    title: "Get GSC coverage history",
+    description: "Get Google Search Console coverage history snapshots for a Canonry project.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: gscCoverageHistoryInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/coverage/history"],
+    handler: (client, input) => client.gscCoverageHistory(input.project, { limit: input.limit })
+  }),
+  defineTool({
+    name: "canonry_gsc_sitemaps",
+    title: "Get GSC sitemaps",
+    description: "Get sitemap data from Google Search Console for a Canonry project.",
+    access: "read",
+    tier: "gsc",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(true),
+    openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/sitemaps"],
+    handler: (client, input) => client.gscSitemaps(input.project)
+  }),
+  defineTool({
+    name: "canonry_ga_status",
+    title: "Get GA status",
+    description: "Get Google Analytics connection status for a Canonry project.",
+    access: "read",
+    tier: "ga",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/status"],
+    handler: (client, input) => client.gaStatus(input.project)
+  }),
+  defineTool({
+    name: "canonry_ga_traffic",
+    title: "Get GA traffic",
+    description: "Get Google Analytics traffic summary for a Canonry project.",
+    access: "read",
+    tier: "ga",
+    inputSchema: gaTrafficInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/traffic"],
+    handler: (client, input) => client.gaTraffic(input.project, compactStringParams(input, ["limit", "window"]))
+  }),
+  defineTool({
+    name: "canonry_ga_coverage",
+    title: "Get GA coverage",
+    description: "Get Google Analytics page coverage for a Canonry project.",
+    access: "read",
+    tier: "ga",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/coverage"],
+    handler: (client, input) => client.gaCoverage(input.project)
+  }),
+  defineTool({
+    name: "canonry_ga_ai_referral_history",
+    title: "Get GA AI referral history",
+    description: "Get AI referral sessions per day grouped by source.",
+    access: "read",
+    tier: "ga",
+    inputSchema: gaWindowInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/ai-referral-history"],
+    handler: (client, input) => client.gaAiReferralHistory(input.project, compactStringParams(input, ["window"]))
+  }),
+  defineTool({
+    name: "canonry_ga_social_referral_history",
+    title: "Get GA social referral history",
+    description: "Get social referral sessions per day grouped by source.",
+    access: "read",
+    tier: "ga",
+    inputSchema: gaWindowInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/social-referral-history"],
+    handler: (client, input) => client.gaSocialReferralHistory(input.project, compactStringParams(input, ["window"]))
+  }),
+  defineTool({
+    name: "canonry_ga_social_referral_trend",
+    title: "Get GA social referral trend",
+    description: "Get social referral trend with biggest mover for a Canonry project.",
+    access: "read",
+    tier: "ga",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/social-referral-trend"],
+    handler: (client, input) => client.gaSocialReferralTrend(input.project)
+  }),
+  defineTool({
+    name: "canonry_ga_attribution_trend",
+    title: "Get GA attribution trend",
+    description: "Get per-channel attribution trends for organic, AI, social, direct, and total sessions.",
+    access: "read",
+    tier: "ga",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/attribution-trend"],
+    handler: (client, input) => client.gaAttributionTrend(input.project)
+  }),
+  defineTool({
+    name: "canonry_ga_session_history",
+    title: "Get GA session history",
+    description: "Get total sessions per day for a Canonry project.",
+    access: "read",
+    tier: "ga",
+    inputSchema: gaWindowInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/ga/session-history"],
+    handler: (client, input) => client.gaSessionHistory(input.project, compactStringParams(input, ["window"]))
+  }),
+  defineTool({
+    name: "canonry_project_upsert",
+    title: "Create or replace project",
+    description: "Create or replace a Canonry project. PUT semantics \u2014 fields not in the request are reset to their defaults. Provide the full intended project shape.",
+    access: "write",
+    tier: "setup",
+    inputSchema: projectUpsertInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["PUT /api/v1/projects/{name}"],
+    handler: (client, input) => client.putProject(input.project, input.request)
+  }),
+  defineTool({
+    name: "canonry_apply_config",
+    title: "Apply project config",
+    description: "Apply one Canonry config-as-code project document. Replaces the project to match the config \u2014 fields omitted from the spec are reset to defaults. For multi-document YAML, call this tool once per project document.",
+    access: "write",
+    tier: "core",
+    inputSchema: applyConfigInputSchema,
+    // Declarative apply is safe to repeat, but it replaces configured child state.
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["POST /api/v1/apply"],
+    handler: (client, input) => client.apply(input.config)
+  }),
+  defineTool({
+    name: "canonry_keywords_generate",
+    title: "Generate keyword suggestions",
+    description: "Generate candidate key phrases using a configured provider. Returns suggestions only; use canonry_keywords_add to persist them.",
+    access: "write",
+    tier: "setup",
+    inputSchema: keywordGenerateInputSchema,
+    annotations: writeAnnotations({ idempotentHint: false, openWorldHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/keywords/generate"],
+    handler: (client, input) => client.generateKeywords(input.project, input.request.provider, input.request.count)
+  }),
+  defineTool({
+    name: "canonry_keywords_replace",
+    title: "Replace keywords",
+    description: "Replace the tracked keyword set for a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: keywordsInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["PUT /api/v1/projects/{name}/keywords"],
+    handler: async (client, input) => {
+      await client.putKeywords(input.project, uniqueStrings(input.request.keywords));
+    }
+  }),
+  defineTool({
+    name: "canonry_run_trigger",
+    title: "Trigger run",
+    description: "Trigger an answer-visibility run for a Canonry project.",
+    access: "write",
+    tier: "core",
+    inputSchema: runTriggerInputSchema,
+    annotations: writeAnnotations({ idempotentHint: false, openWorldHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/runs"],
+    handler: (client, input) => client.triggerRun(input.project, input.request)
+  }),
+  defineTool({
+    name: "canonry_run_cancel",
+    title: "Cancel run",
+    description: "Cancel a queued or running Canonry run.",
+    access: "write",
+    tier: "core",
+    inputSchema: runGetInputSchema,
+    annotations: writeAnnotations({ idempotentHint: false, destructiveHint: true }),
+    openApiOperations: ["POST /api/v1/runs/{id}/cancel"],
+    handler: (client, input) => client.cancelRun(input.runId)
+  }),
+  defineTool({
+    name: "canonry_keywords_add",
+    title: "Add keywords",
+    description: "Append tracked keywords to a Canonry project; existing keywords are skipped by the API.",
+    access: "write",
+    tier: "setup",
+    inputSchema: keywordsInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/keywords"],
+    handler: async (client, input) => {
+      await client.appendKeywords(input.project, uniqueStrings(input.request.keywords));
+    }
+  }),
+  defineTool({
+    name: "canonry_keywords_remove",
+    title: "Remove keywords",
+    description: "Remove tracked keywords from a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: keywordsInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["DELETE /api/v1/projects/{name}/keywords"],
+    handler: async (client, input) => {
+      await client.deleteKeywords(input.project, uniqueStrings(input.request.keywords));
+    }
+  }),
+  defineTool({
+    name: "canonry_competitors_add",
+    title: "Add competitors",
+    description: "Add tracked competitor domains to a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: competitorsInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/competitors"],
+    handler: async (client, input) => {
+      await client.appendCompetitors(input.project, uniqueStrings(input.request.competitors));
+    }
+  }),
+  defineTool({
+    name: "canonry_competitors_remove",
+    title: "Remove competitors",
+    description: "Remove tracked competitor domains from a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: competitorsInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["DELETE /api/v1/projects/{name}/competitors"],
+    handler: async (client, input) => {
+      await client.deleteCompetitors(input.project, uniqueStrings(input.request.competitors));
+    }
+  }),
+  defineTool({
+    name: "canonry_schedule_set",
+    title: "Set schedule",
+    description: "Create or replace the scheduled run configuration for a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: scheduleSetInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true }),
+    openApiOperations: ["PUT /api/v1/projects/{name}/schedule"],
+    handler: (client, input) => client.putSchedule(input.project, input.schedule)
+  }),
+  defineTool({
+    name: "canonry_schedule_delete",
+    title: "Delete schedule",
+    description: "Delete the scheduled run configuration for a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: projectInputSchema,
+    annotations: writeAnnotations({ idempotentHint: false, destructiveHint: true }),
+    openApiOperations: ["DELETE /api/v1/projects/{name}/schedule"],
+    handler: async (client, input) => {
+      await client.deleteSchedule(input.project);
+    }
+  }),
+  defineTool({
+    name: "canonry_insight_dismiss",
+    title: "Dismiss insight",
+    description: "Dismiss an intelligence insight for a Canonry project.",
+    access: "write",
+    tier: "setup",
+    inputSchema: insightInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/insights/{id}/dismiss"],
+    handler: (client, input) => client.dismissInsight(input.project, input.insightId)
+  }),
+  defineTool({
+    name: "canonry_memory_list",
+    title: "List agent memory",
+    description: "Read project-scoped durable notes Aero has stored via canonry_memory_set (plus compaction summaries). Returns entries newest-first. The N most-recent entries are also injected into the system prompt at session start, so you usually do not need to call this \u2014 reach for it when you need older context or the full note value.",
+    access: "read",
+    tier: "agent",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/agent/memory"],
+    handler: (client, input) => client.listAgentMemory(input.project)
+  }),
+  defineTool({
+    name: "canonry_memory_set",
+    title: "Upsert agent memory",
+    description: 'Persist a project-scoped durable note visible to every future Aero session for this project. Upsert \u2014 writing the same key replaces the prior value. Capped at 2 KB per note. Reserved key prefix "compaction:" is rejected.',
+    access: "write",
+    tier: "agent",
+    inputSchema: memoryUpsertInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true }),
+    openApiOperations: ["PUT /api/v1/projects/{name}/agent/memory"],
+    handler: (client, input) => client.setAgentMemory(input.project, { key: input.key, value: input.value })
+  }),
+  defineTool({
+    name: "canonry_memory_forget",
+    title: "Delete agent memory",
+    description: 'Delete a durable note by key. Returns status="missing" (non-error) when the key did not exist. Reserved key prefix "compaction:" cannot be forgotten directly \u2014 those notes are pruned automatically.',
+    access: "write",
+    tier: "agent",
+    inputSchema: memoryForgetInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["DELETE /api/v1/projects/{name}/agent/memory"],
+    handler: (client, input) => client.forgetAgentMemory(input.project, input.key)
+  }),
+  defineTool({
+    name: "canonry_agent_clear",
+    title: "Clear agent transcript",
+    description: "Clear the rolling Aero conversation for a project \u2014 wipes the transcript, the in-memory pending follow-up buffer, and the persisted follow-up queue. Memory entries (canonry_memory_*) are preserved. Use when starting a fresh dialogue or when the operator wants to reset context.",
+    access: "write",
+    tier: "agent",
+    inputSchema: projectInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["DELETE /api/v1/projects/{name}/agent/transcript"],
+    handler: async (client, input) => {
+      await client.resetAgentTranscript(input.project);
+      return { status: "cleared", project: input.project };
+    }
+  }),
+  defineTool({
+    name: "canonry_agent_webhook_attach",
+    title: "Attach agent webhook",
+    description: "Attach an external agent webhook to project run and insight events.",
+    access: "write",
+    tier: "core",
+    inputSchema: agentWebhookAttachInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true }),
+    openApiOperations: ["GET /api/v1/projects/{name}/notifications", "POST /api/v1/projects/{name}/notifications"],
+    handler: async (client, input) => {
+      const existing = await client.listNotifications(input.project);
+      const agentNotification = existing.find((notification2) => notification2.source === "agent");
+      if (agentNotification) {
+        return { status: "already-attached", project: input.project, notificationId: agentNotification.id };
+      }
+      const request = notificationCreateRequestSchema.parse({
+        channel: "webhook",
+        url: input.url,
+        events: AGENT_WEBHOOK_EVENTS,
+        source: "agent"
+      });
+      const notification = await client.createNotification(input.project, request);
+      return { status: "attached", project: input.project, notificationId: notification.id };
+    }
+  }),
+  defineTool({
+    name: "canonry_agent_webhook_detach",
+    title: "Detach agent webhook",
+    description: "Detach the external agent webhook for a Canonry project.",
+    access: "write",
+    tier: "agent",
+    inputSchema: projectInputSchema,
+    annotations: writeAnnotations({ idempotentHint: true, destructiveHint: true }),
+    openApiOperations: ["GET /api/v1/projects/{name}/notifications", "DELETE /api/v1/projects/{name}/notifications/{id}"],
+    handler: async (client, input) => {
+      const existing = await client.listNotifications(input.project);
+      const agentNotification = existing.find((notification) => notification.source === "agent");
+      if (!agentNotification) {
+        return { status: "not-attached", project: input.project };
+      }
+      await client.deleteNotification(input.project, agentNotification.id);
+      return { status: "detached", project: input.project };
+    }
+  })
+];
+var CANONRY_MCP_TOOL_COUNT = canonryMcpTools.length;
+var CANONRY_MCP_READ_TOOL_COUNT = canonryMcpTools.filter((tool) => tool.access === "read").length;
+var CANONRY_MCP_CORE_TOOL_COUNT = canonryMcpTools.filter((tool) => tool.tier === "core").length;
+
 export {
   getConfigDir,
   getConfigPath,
@@ -2562,11 +3483,9 @@ export {
   resolveProviderInput,
   locationContextSchema,
   notificationEventSchema,
-  notificationCreateRequestSchema,
   findDuplicateLocationLabels,
   hasLocationLabel,
   projectUpsertRequestSchema,
-  keywordBatchRequestSchema,
   keywordGenerateRequestSchema,
   competitorBatchRequestSchema,
   normalizeProjectDomain,
@@ -2611,7 +3530,6 @@ export {
   brandKeyFromText,
   MemorySources,
   AGENT_MEMORY_VALUE_MAX_BYTES,
-  AGENT_MEMORY_KEY_MAX_LENGTH,
   agentMemoryUpsertRequestSchema,
   agentMemoryDeleteRequestSchema,
   CcReleaseSyncStatuses,
@@ -2621,5 +3539,6 @@ export {
   summarizeCheckResults,
   normalizeUrlPath,
   createApiClient,
-  ApiClient
+  ApiClient,
+  canonryMcpTools
 };