@canonry/canonry 7.65.1 → 7.67.0

package/dist/{chunk-2AROR73F.js → chunk-32BTTG5N.js}

@@ -5,7 +5,7 @@ import {
   isStoredPageReadTool,
   isStoredReadTool,
   truncateToolResult
-} from "./chunk-CRKOGLKJ.js";
+} from "./chunk-XIA6NWIF.js";
 import {
   CANONRY_MCP_TOOLKITS
 } from "./chunk-NDTU7FGL.js";
@@ -22,15 +22,15 @@ import {
   resolveApiKeyFor,
   resolveModelForProvider,
   validateAgentProviderRegistry
-} from "./chunk-C2PYKUD3.js";
+} from "./chunk-UNCOK6DA.js";
 import {
   CanonryMcpToolNames,
   canonryMcpTools
-} from "./chunk-BV6NXSAH.js";
+} from "./chunk-37R6GTU7.js";
 import {
   agentToolEvents,
   llmUsageEvents
-} from "./chunk-XOMUSIM7.js";
+} from "./chunk-6DJN7HCK.js";
 import {
   MeasurementPortfolioLists,
   agentTurnLimitsSchema,
@@ -38,7 +38,7 @@ import {
   describeError,
   validationError,
   visibilityReportRequestSchema
-} from "./chunk-DQVJB6CZ.js";
+} from "./chunk-XEGYSZEV.js";
 
 // src/agent/session.ts
 import fs3 from "fs";

package/dist/{chunk-BV6NXSAH.js → chunk-37R6GTU7.js}

@@ -2,11 +2,11 @@ import {
   dedupeGscSitemapUrls,
   resolveDiscoveredGscSitemapUrls,
   submitGscSitemapBatches
-} from "./chunk-ZWZOQNLD.js";
+} from "./chunk-WSYLDPYF.js";
 import {
   measurementDraftOperationSchema,
   runMeasurementDraftAction
-} from "./chunk-ZPRJCSSR.js";
+} from "./chunk-LU3M54IY.js";
 import {
   CliError
 } from "./chunk-HGMYEDAQ.js";
@@ -141,6 +141,8 @@ import {
   seoDomainIntelligenceListSchema,
   seoEvidenceQuerySchema,
   seoKeywordMetricsListSchema,
+  seoMarketRankingListSchema,
+  seoMarketRankingQuerySchema,
   seoOperatorTaskSchema,
   seoOverviewSchema,
   seoProfileInputSchema,
@@ -173,7 +175,7 @@ import {
   trafficSeriesGranularitySchema,
   visibilityCompareSelectionSchema,
   visibilityReportRequestSchema
-} from "./chunk-DQVJB6CZ.js";
+} from "./chunk-XEGYSZEV.js";
 
 // src/mcp/tool-registry.ts
 import { z as z2 } from "zod";
@@ -1123,6 +1125,7 @@ var sentimentPreviewInputSchema = sentimentBackfillSelectionSchema.safeExtend({
 var sentimentBackfillInputSchema = sentimentBackfillRequestSchema.extend({ project: projectNameSchema });
 var seoIdInputSchema = projectInputSchema.extend({ id: z2.string().min(1) });
 var seoEvidenceInputSchema = seoEvidenceQuerySchema.extend({ project: projectNameSchema });
+var seoMarketRankingInputSchema = seoMarketRankingQuerySchema.extend({ project: projectNameSchema });
 var rawCanonryMcpTools = [
   defineTool({
     name: "canonry_seo_operator_task",
@@ -1334,6 +1337,21 @@ var rawCanonryMcpTools = [
       return client.getSeoRankedKeywords(project, query);
     }
   }),
+  defineTool({
+    name: "canonry_seo_market_rankings",
+    title: "SEO market rankings",
+    description: "Read stored SEO data only. No provider calls. The site's Google position for each tracked non-brand query in each market, searched from that market's location; these are the same tracked queries AI visibility measures, and searchText is the exact text searched. searchStatus says how each search ended: a null rank in a completed or partial row means not in the checked results (depth, lower when only part of the results came back); a failed or cancelled row has no rank because the search returned nothing. Filter with marketKey or regionKey and keep runId fixed while paging.",
+    access: "read",
+    tier: "seo",
+    inputSchema: seoMarketRankingInputSchema,
+    outputSchema: seoMarketRankingListSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/seo/market-rankings"],
+    handler: (client, input) => {
+      const { project, ...query } = input;
+      return client.getSeoMarketRankings(project, query);
+    }
+  }),
   defineTool({
     name: "canonry_sentiment_settings",
     title: "Read sentiment readiness and settings",

package/dist/{chunk-HPUZMBS6.js → chunk-5DMESZDF.js}

@@ -1,6 +1,6 @@
 import {
   parseJsonColumn
-} from "./chunk-XOMUSIM7.js";
+} from "./chunk-6DJN7HCK.js";
 import {
   AI_ENGINE_DOMAINS,
   AI_ENGINE_SELF_DOMAINS,
@@ -26,7 +26,7 @@ import {
   retryAfterDelayMs,
   usageCount,
   withRetry
-} from "./chunk-DQVJB6CZ.js";
+} from "./chunk-XEGYSZEV.js";
 
 // ../provider-openai/src/normalize.ts
 import OpenAI from "openai";

package/dist/{chunk-XOMUSIM7.js → chunk-6DJN7HCK.js}

@@ -20,7 +20,7 @@ import {
   templateLinkRatio,
   templateLinkUbiquityAvailable,
   validationError
-} from "./chunk-DQVJB6CZ.js";
+} from "./chunk-XEGYSZEV.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -227,8 +227,10 @@ var seoTasks = sqliteTable("seo_tasks", {
   reconciliation: text("reconciliation", { mode: "json" }).$type(),
   startedAt: text("started_at"),
   finishedAt: text("finished_at"),
-  error: text("error")
-}, (t) => [index("idx_seo_tasks_job").on(t.jobId)]);
+  error: text("error"),
+  /** Set on a second attempt: the task whose search-engine error it repeats. A retry is never retried. */
+  retryOf: text("retry_of")
+}, (t) => [index("idx_seo_tasks_job").on(t.jobId), index("idx_seo_tasks_retry").on(t.retryOf)]);
 var seoBudgets = sqliteTable("seo_budgets", {
   scope: text("scope").notNull(),
   period: text("period").notNull(),
@@ -971,6 +973,12 @@ var schedules = sqliteTable2("schedules", {
   sourceId: text2("source_id"),
   lastRunAt: text2("last_run_at"),
   nextRunAt: text2("next_run_at"),
+  /**
+   * When the schedule last turned on (created enabled, or changed from disabled to enabled);
+   * null while it is disabled. Rows written before migration 196 hold null while enabled:
+   * read those as enabled since `createdAt`.
+   */
+  enabledAt: text2("enabled_at"),
   createdAt: text2("created_at").notNull(),
   updatedAt: text2("updated_at").notNull()
 }, (table) => [
@@ -8224,6 +8232,28 @@ var MIGRATION_VERSIONS = [
       `ALTER TABLE ga_measurement_sync_state ADD COLUMN key_event_names TEXT`,
       `ALTER TABLE ga_measurement_sync_state ADD COLUMN key_events_error TEXT`
     ]
+  },
+  {
+    // A market-rankings search that hit a search-engine error is sent once
+    // more at the end of its refresh, as a new task that points at the first
+    // attempt. Nullable with no default: existing tasks and every task an
+    // older writer adds are first attempts.
+    version: 195,
+    name: "seo-task-retry",
+    statements: [
+      `ALTER TABLE seo_tasks ADD COLUMN retry_of TEXT`,
+      `CREATE INDEX IF NOT EXISTS idx_seo_tasks_retry ON seo_tasks(retry_of)`
+    ]
+  },
+  {
+    // When a schedule last turned on, so a schedule enabled long after it was
+    // created is graded from that point. Nullable with no default: existing
+    // rows read as enabled since creation, and an older writer leaves it null.
+    version: 196,
+    name: "schedules-enabled-at",
+    statements: [
+      `ALTER TABLE schedules ADD COLUMN enabled_at TEXT`
+    ]
   }
 ];
 var AERO_LEDGER_REBUILDS = [
@@ -9431,6 +9461,20 @@ var SentimentRepository = class {
 // ../db/src/seo-repository.ts
 import crypto from "crypto";
 import { and as and2, asc as asc2, eq as eq3, inArray as inArray2, sql as sql5 } from "drizzle-orm";
+function currentSeoTasks(tasks) {
+  const replaced = new Set(tasks.flatMap((task) => task.retryOf && task.status !== SeoRunStatuses.cancelled ? [task.retryOf] : []));
+  return tasks.filter((task) => task.retryOf ? task.status !== SeoRunStatuses.cancelled : !replaced.has(task.id));
+}
+function currentSeoTaskCondition() {
+  return sql5`(${seoTasks.retryOf} IS NULL OR ${seoTasks.status} <> ${SeoRunStatuses.cancelled}) AND NOT EXISTS (SELECT 1 FROM seo_tasks AS retry WHERE retry.retry_of = ${seoTasks.id} AND retry.status <> ${SeoRunStatuses.cancelled})`;
+}
+function bucketLimits(job, policy) {
+  return /* @__PURE__ */ new Map([
+    [`account-day:${job.accountKey}`, policy.accountDailyLimitMicros],
+    [`account-month:${job.accountKey}`, policy.accountMonthlyLimitMicros],
+    [`project-month:${job.projectKey}`, policy.projectMonthlyLimitMicros]
+  ]);
+}
 var SeoRepository = class {
   constructor(db) {
     this.db = db;
@@ -9481,15 +9525,11 @@ var SeoRepository = class {
       }
       if (tx.select({ id: seoTasks.id }).from(seoTasks).innerJoin(seoJobs, eq3(seoTasks.jobId, seoJobs.id)).where(and2(eq3(seoJobs.accountKey, job.accountKey), inArray2(seoTasks.status, [SeoRunStatuses.running, SeoRunStatuses["reconciliation-required"]]))).get()) return null;
       const allTasks = tx.select().from(seoTasks).where(eq3(seoTasks.jobId, jobId)).orderBy(asc2(seoTasks.id)).all();
-      const task = allTasks.find((row) => row.status === SeoRunStatuses.queued);
+      const task = allTasks.find((row) => row.status === SeoRunStatuses.queued && !row.retryOf) ?? allTasks.find((row) => row.status === SeoRunStatuses.queued);
       if (!task) return null;
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const outstanding = allTasks.filter((row) => row.status === SeoRunStatuses.queued).reduce((sum, row) => sum + row.reservedMicros, 0);
-      const limits = /* @__PURE__ */ new Map([
-        [`account-day:${job.accountKey}`, policy.accountDailyLimitMicros],
-        [`account-month:${job.accountKey}`, policy.accountMonthlyLimitMicros],
-        [`project-month:${job.projectKey}`, policy.projectMonthlyLimitMicros]
-      ]);
+      const limits = bucketLimits(job, policy);
       const buckets = job.buckets.map((bucket) => ({ ...bucket, limit: limits.get(bucket.scope) ?? 0, period: now.slice(0, bucket.scope.startsWith("account-day:") ? 10 : 7) }));
       const runMaximum = allTasks.reduce((sum, row) => sum + (row.actualMicros ?? row.reservedMicros), 0);
       const allowed = runMaximum <= policy.maxRunCostMicros && buckets.every((bucket) => {
@@ -9520,7 +9560,11 @@ var SeoRepository = class {
   renew(taskId, owner) {
     this.db.update(seoTasks).set({ leaseUntil: new Date(Date.now() + 12e4).toISOString() }).where(and2(eq3(seoTasks.id, taskId), eq3(seoTasks.leaseOwner, owner), eq3(seoTasks.status, SeoRunStatuses.running))).run();
   }
-  settle(taskId, result, owner) {
+  /**
+   * Store a task's outcome. With `retryPolicy`, a search the adapter marks `retryable` gets one
+   * more attempt, queued in the same transaction (see `queueRetry`).
+   */
+  settle(taskId, result, owner, retryPolicy) {
     return this.db.transaction((tx) => {
       const task = tx.select().from(seoTasks).where(eq3(seoTasks.id, taskId)).get();
       if (!task || task.leaseOwner !== owner || task.reconciliation || task.status !== SeoRunStatuses.running && task.status !== SeoRunStatuses["reconciliation-required"]) return false;
@@ -9532,10 +9576,36 @@ var SeoRepository = class {
       if (known) for (const bucket of job.buckets) tx.update(seoBudgets).set({ reservedMicros: sql5`${seoBudgets.reservedMicros} - ${task.reservedMicros}`, spentMicros: sql5`${seoBudgets.spentMicros} + ${actual}` }).where(and2(eq3(seoBudgets.scope, bucket.scope), eq3(seoBudgets.period, bucket.period))).run();
       const error = status === SeoRunStatuses["reconciliation-required"] ? "The upstream outcome needs operator reconciliation. This request will not be retried." : status === SeoRunStatuses.failed ? "The SEO provider could not complete this task." : null;
       tx.update(seoTasks).set({ status, collectionOutcome: result.outcome, actualMicros: known ? actual : null, receipts: result.tasks, results: result.results, error, leaseOwner: null, leaseUntil: null, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq3(seoTasks.id, taskId)).run();
+      if (status === SeoRunStatuses.failed && result.retryable === true && retryPolicy) this.queueRetry(tx, task, job, retryPolicy);
       this.finish(job.id);
       return true;
     }, { behavior: "immediate" });
   }
+  /**
+   * Queue the one retry a search gets after a search-engine error. It reserves the first attempt's
+   * amount again, inside the same limits, and claims take it after every first attempt, so it runs
+   * at the end of the refresh. A retry is never retried, a cancelled refresh gets none, and one that
+   * would pass a limit is not queued, leaving the search failed.
+   */
+  queueRetry(tx, task, job, policy) {
+    if (job.cancelRequested || task.retryOf || tx.select({ id: seoTasks.id }).from(seoTasks).where(eq3(seoTasks.retryOf, task.id)).get()) return;
+    const amount = task.reservedMicros;
+    const runCost = tx.select({ actualMicros: seoTasks.actualMicros, reservedMicros: seoTasks.reservedMicros }).from(seoTasks).where(eq3(seoTasks.jobId, job.id)).all().reduce((sum, row) => sum + (row.actualMicros ?? row.reservedMicros), 0);
+    if (runCost + amount > policy.maxRunCostMicros) return;
+    const limits = bucketLimits(job, policy);
+    const fits = job.buckets.every((bucket) => {
+      const current = tx.select({ spentMicros: seoBudgets.spentMicros }).from(seoBudgets).where(and2(eq3(seoBudgets.scope, bucket.scope), eq3(seoBudgets.period, bucket.period))).get();
+      const held = tx.select({ total: sql5`coalesce(sum(${seoBudgets.reservedMicros}),0)` }).from(seoBudgets).where(eq3(seoBudgets.scope, bucket.scope)).get().total;
+      return (current?.spentMicros ?? 0) + held + amount <= (limits.get(bucket.scope) ?? 0);
+    });
+    if (!fits) return;
+    for (const bucket of job.buckets) {
+      tx.insert(seoBudgets).values({ scope: bucket.scope, period: bucket.period }).onConflictDoNothing().run();
+      tx.update(seoBudgets).set({ reservedMicros: sql5`${seoBudgets.reservedMicros} + ${amount}` }).where(and2(eq3(seoBudgets.scope, bucket.scope), eq3(seoBudgets.period, bucket.period))).run();
+    }
+    const id = crypto.randomUUID();
+    tx.insert(seoTasks).values({ id, jobId: job.id, request: { ...task.request, tag: id }, status: SeoRunStatuses.queued, reservedMicros: amount, catalogRevision: task.catalogRevision, results: emptySeoResults(), retryOf: task.id }).run();
+  }
   cancel(jobId) {
     return this.db.transaction((tx) => {
       const job = tx.select().from(seoJobs).where(eq3(seoJobs.id, jobId)).get();
@@ -9581,7 +9651,7 @@ var SeoRepository = class {
   }
   finish(jobId) {
     const job = this.db.select().from(seoJobs).where(eq3(seoJobs.id, jobId)).get();
-    const tasks = this.db.select().from(seoTasks).where(eq3(seoTasks.jobId, jobId)).all();
+    const tasks = currentSeoTasks(this.db.select().from(seoTasks).where(eq3(seoTasks.jobId, jobId)).all());
     const pending = tasks.some((task) => task.status === SeoRunStatuses.queued || task.status === SeoRunStatuses.running);
     const unknown = tasks.some((task) => task.status === SeoRunStatuses["reconciliation-required"]);
     const completed = tasks.some((task) => task.status === SeoRunStatuses.completed || task.status === SeoRunStatuses.partial);
@@ -9758,5 +9828,7 @@ export {
   SentimentIdempotencyConflict,
   recordSentimentCompletion,
   SentimentRepository,
+  currentSeoTasks,
+  currentSeoTaskCondition,
   SeoRepository
 };