@canonry/canonry 6.1.4 → 6.2.0

package/dist/{chunk-5LZLDXEN.js → chunk-2RFHQ6XT.js}

@@ -19,21 +19,21 @@ import {
   runWithUsageTags,
   saveConfigPatch,
   sentimentInstallReadiness
-} from "./chunk-YOMLHHJS.js";
+} from "./chunk-V6JUBTNL.js";
 import {
   computeFactorAverages,
   deleteSiteCrawlGraphLayout,
   persistSiteCrawlGraphLayout,
   prepareSiteCrawlGraphLayout,
   recordedSharePct
-} from "./chunk-HB6XZOZ6.js";
+} from "./chunk-4EKOKWQT.js";
 import {
   CanonryMcpToolNames,
   CliError,
   PACKAGE_VERSION,
   canonryMcpTools,
   isMachineFormat
-} from "./chunk-6CR7DWLU.js";
+} from "./chunk-W3GDZZNF.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -214,7 +214,7 @@ import {
   siteLivenessState,
   toAlertView,
   usageCounters
-} from "./chunk-N7MRAN3G.js";
+} from "./chunk-ENI3GOWW.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_NONE,
@@ -304,6 +304,7 @@ import {
   canonicalizeGtmAccountId,
   canonicalizeGtmContainerId,
   canonicalizeGtmResourceSelection,
+  classifyProviderErrorMessage,
   classifyProviderErrorMessages,
   classifyTemplateLinkEdge,
   cloudflareQueueNameSchema,
@@ -327,6 +328,7 @@ import {
   effectiveBrandNames,
   effectiveDomains,
   embedClientConfigForRequest,
+  extractProviderHttpStatus,
   factorStatusFromScore,
   filterCapturedCitedUrls,
   forbidden,
@@ -414,7 +416,7 @@ import {
   visibilityReportRequestSchema,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-4MWLHTRS.js";
+} from "./chunk-6EPN4XY5.js";
 
 // src/runtime-context.ts
 function cliRuntimeContext(env = process.env, stdio = process) {
@@ -4053,6 +4055,19 @@ import os4 from "os";
 import { GoogleGenAI } from "@google/genai";
 
 // ../provider-gemini/src/utils.ts
+var GEMINI_MAX_RATE_LIMIT_WAIT_MS = 65e3;
+function geminiRetryDelayMs(err) {
+  const match = /"retryDelay"\s*:\s*"(\d+(?:\.\d+)?)s"/.exec(describeError(err));
+  return match ? Math.round(Number(match[1]) * 1e3) : null;
+}
+function isGeminiDailyQuotaError(err) {
+  return /"quotaId"\s*:\s*"[^"]*PerDay/i.test(describeError(err));
+}
+function isGeminiRetryable(err) {
+  if (!isRetryableHttpError(err) || isGeminiDailyQuotaError(err)) return false;
+  const asked = geminiRetryDelayMs(err);
+  return asked === null || asked <= GEMINI_MAX_RATE_LIMIT_WAIT_MS;
+}
 async function withRetry2(fn, options = {}) {
   return withRetry(fn, {
     maxRetries: options.maxRetries ?? 3,
@@ -4061,7 +4076,12 @@ async function withRetry2(fn, options = {}) {
     // provider has shipped to date (1000, 2000, 4000ms). Enable per-caller
     // if you need it.
     jitter: false,
-    isRetryable: isRetryableHttpError,
+    isRetryable: isGeminiRetryable,
+    computeDelayMs: (_attempt, err, defaultMs) => {
+      const asked = geminiRetryDelayMs(err);
+      return asked === null ? defaultMs : asked + 500;
+    },
+    ...options.sleep ? { sleep: options.sleep } : {},
     onRetry: ({ attempt, err, delayMs }) => {
       console.warn(
         `[provider] Attempt ${attempt + 1} failed, retrying in ${delayMs}ms...`,
@@ -4072,7 +4092,7 @@ async function withRetry2(fn, options = {}) {
 }
 
 // ../provider-gemini/src/normalize.ts
-var DEFAULT_MODEL = "gemini-2.5-flash";
+var DEFAULT_MODEL = "gemini-flash-latest";
 function isVertexConfig(config) {
   return !!config.vertexProject;
 }
@@ -4515,10 +4535,20 @@ var geminiAdapter = {
   keyUrl: "https://aistudio.google.com/apikey",
   // Upstream model list: https://ai.google.dev/gemini-api/docs/models
   modelRegistry: {
-    defaultModel: "gemini-2.5-flash",
+    defaultModel: "gemini-flash-latest",
     validationPattern: /./,
-    validationHint: "any valid Google model name (e.g. gemini-2.5-flash, learnlm-1.5-pro-experimental)",
+    validationHint: "any valid Google model name (e.g. gemini-flash-latest, gemini-3.8-flash)",
     knownModels: [
+      // Google's moving aliases: always the newest Flash / Flash-Lite, with
+      // 2 weeks' email notice before a breaking change. The model actually
+      // served is recorded per snapshot (`servedModel`), so trends still show
+      // when the model behind an alias changed.
+      { id: "gemini-flash-latest", displayName: "Gemini Flash (latest)", tier: "standard" },
+      { id: "gemini-flash-lite-latest", displayName: "Gemini Flash-Lite (latest)", tier: "economy" },
+      { id: "gemini-3.8-flash", displayName: "Gemini 3.8 Flash", tier: "standard" },
+      { id: "gemini-3.5-flash-lite", displayName: "Gemini 3.5 Flash-Lite", tier: "economy" },
+      // Google limits the 2.5 models to projects that already used them, so a
+      // new key may be refused. Listed for installs that still pin them.
       { id: "gemini-2.5-pro", displayName: "Gemini 2.5 Pro", tier: "flagship" },
       { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", tier: "standard" },
       { id: "gemini-2.5-flash-lite", displayName: "Gemini 2.5 Flash-Lite", tier: "economy" },
@@ -7830,7 +7860,7 @@ function nonBlank(value) {
   return trimmed ? trimmed : void 0;
 }
 function resolveBuildCommit(env = process.env) {
-  const embedded = true ? "5bfed51c11b95f292c522e93568efee2f164c4ed" : void 0;
+  const embedded = true ? "633bd63832cf6af1da610e63f376dfc872975b49" : void 0;
   return nonBlank(embedded) ?? nonBlank(env.CANONRY_COMMIT);
 }
 function resolveInstanceIdentity(env = process.env) {
@@ -7845,7 +7875,8 @@ import crypto6 from "crypto";
 import fs4 from "fs";
 import path3 from "path";
 import os3 from "os";
-import { and as and3, asc as asc2, count, eq as eq3, inArray, isNotNull, isNull, ne, sql as sql2 } from "drizzle-orm";
+import { setImmediate as yieldToEventLoop } from "timers/promises";
+import { and as and3, asc as asc2, count, desc, eq as eq3, inArray, isNotNull, isNull, lt, ne, sql as sql2 } from "drizzle-orm";
 
 // src/run-telemetry.ts
 import crypto4 from "crypto";
@@ -7910,6 +7941,51 @@ function buildSiteAuditCompletedProps(input) {
   if (crawl.checkDeadLinks) props.deadLinksFound = crawl.deadLinksFound;
   return props;
 }
+var MAX_NESTED_KEYS = 12;
+function buildProviderOutcomeProps(providers, providerErrors) {
+  if (providerErrors.size === 0) return {};
+  const names = [.../* @__PURE__ */ new Set([...providers, ...providerErrors.keys()])].slice(0, MAX_NESTED_KEYS);
+  const providerOutcomes = {};
+  const providerHttpStatus = {};
+  for (const name of names) {
+    const message = providerErrors.get(name);
+    if (message === void 0) {
+      providerOutcomes[name] = "ok";
+      continue;
+    }
+    providerOutcomes[name] = classifyProviderErrorMessage(message);
+    const status = extractProviderHttpStatus(message);
+    if (status !== void 0) providerHttpStatus[name] = status;
+  }
+  return Object.keys(providerHttpStatus).length > 0 ? { providerOutcomes, providerHttpStatus } : { providerOutcomes };
+}
+function runFailureSite(providerCallStart, providerCallEnd) {
+  if (providerCallStart === void 0) return "setup";
+  return providerCallEnd === void 0 ? "provider_call" : "finalize";
+}
+var ERROR_NAME_RE = /^[a-z_$][\w$]{0,39}$/i;
+var ERROR_SYS_CODE_RE = /^[A-Z][A-Z0-9_]{1,39}$/;
+function describeRunFailure(err, site) {
+  const props = site ? { errorSite: site } : {};
+  const name = err instanceof Error ? err.name : typeof err;
+  if (ERROR_NAME_RE.test(name)) props.errorName = name;
+  const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+  if (typeof code === "string" && ERROR_SYS_CODE_RE.test(code)) props.errorSysCode = code;
+  return props;
+}
+var FAILURE_STREAK_SAMPLE_AFTER = 5;
+var FAILURE_STREAK_SAMPLE_RATE = 20;
+function failureStreakSampling(status, priorStreak, runId) {
+  if (status !== "failed" && status !== "partial") return { report: true, props: {} };
+  if (priorStreak < FAILURE_STREAK_SAMPLE_AFTER) {
+    return { report: true, props: { failureStreak: priorStreak } };
+  }
+  const bucket = crypto4.createHash("sha256").update(runId).digest().readUInt32BE(0) % FAILURE_STREAK_SAMPLE_RATE;
+  return {
+    report: bucket === 0,
+    props: { failureStreak: priorStreak, sampleRate: FAILURE_STREAK_SAMPLE_RATE }
+  };
+}
 
 // src/provider-execution-gate.ts
 var ProviderExecutionGate = class {
@@ -8115,6 +8191,8 @@ async function runWithConcurrency(items, limit, worker) {
   await Promise.all(Array.from({ length: cap }, next));
 }
 var PROVIDER_FANOUT_DEFAULT = 8;
+var BATCH_INGEST_CHUNK_SIZE = 32;
+var BATCH_INGEST_PAYLOAD_BYTES = 1024 * 1024;
 var SYNC_SLOT_DISPATCH = {
   idempotent: false,
   mode: ProviderDispatchModes.sync,
@@ -8256,6 +8334,7 @@ function classifyRunAbortReason(message) {
   if (/^Run [^ ]+ is not executable\b/.test(message)) return "run_not_executable";
   return void 0;
 }
+var FAILURE_STREAK_LOOKBACK = 50;
 function classifyProviderErrors(errors) {
   return classifyProviderErrorMessages(errors.values());
 }
@@ -8850,21 +8929,28 @@ var JobRunner = class {
           ...executionContext.location ? { location: executionContext.location } : {}
         });
       } else {
-        trackEvent(
-          "run.completed",
-          buildRunCompletedProps({
-            status: "failed",
-            providerCount: executionContext.providerCount,
-            providers: executionContext.providers,
-            queryCount: executionContext.queryCount,
-            startTime,
-            trigger: executionContext.trigger,
-            canonicalDomain: executionContext.canonicalDomain,
-            phases,
-            location: executionContext.location
-          }),
-          { errorCode: "UNKNOWN" }
-        );
+        const sampling = failureStreakSampling("failed", this.priorFailureStreak(projectId, runId), runId);
+        if (sampling.report) {
+          trackEvent(
+            "run.completed",
+            {
+              ...buildRunCompletedProps({
+                status: "failed",
+                providerCount: executionContext.providerCount,
+                providers: executionContext.providers,
+                queryCount: executionContext.queryCount,
+                startTime,
+                trigger: executionContext.trigger,
+                canonicalDomain: executionContext.canonicalDomain,
+                phases,
+                location: executionContext.location
+              }),
+              ...describeRunFailure(err, runFailureSite(providerCallStart, providerCallEnd)),
+              ...sampling.props
+            },
+            { errorCode: "INTERNAL" }
+          );
+        }
       }
       if (this.onRunCompleted) {
         this.onRunCompleted(runId, projectId).catch((notifErr) => {
@@ -8928,21 +9014,28 @@ var JobRunner = class {
   reportFinalizedRun(input, finalStatus) {
     const { runId, projectId, providerErrors, executionContext } = input;
     const failureCode = providerErrors.size > 0 ? classifyProviderErrors(providerErrors) : void 0;
-    trackEvent(
-      "run.completed",
-      buildRunCompletedProps({
-        status: finalStatus,
-        providerCount: executionContext.providerCount,
-        providers: executionContext.providers,
-        queryCount: executionContext.queryCount,
-        startTime: input.startTime,
-        trigger: executionContext.trigger,
-        canonicalDomain: executionContext.canonicalDomain,
-        phases: input.phases,
-        location: executionContext.location
-      }),
-      failureCode ? { errorCode: failureCode } : void 0
-    );
+    const sampling = failureStreakSampling(finalStatus, this.priorFailureStreak(projectId, runId), runId);
+    if (sampling.report) {
+      trackEvent(
+        "run.completed",
+        {
+          ...buildRunCompletedProps({
+            status: finalStatus,
+            providerCount: executionContext.providerCount,
+            providers: executionContext.providers,
+            queryCount: executionContext.queryCount,
+            startTime: input.startTime,
+            trigger: executionContext.trigger,
+            canonicalDomain: executionContext.canonicalDomain,
+            phases: input.phases,
+            location: executionContext.location
+          }),
+          ...buildProviderOutcomeProps(executionContext.providers, providerErrors),
+          ...sampling.props
+        },
+        failureCode ? { errorCode: failureCode } : void 0
+      );
+    }
     if (input.kind === RunKinds["answer-visibility"] && executionContext.trigger !== RunTriggers.probe && input.inserted > 0 && !this.hasPriorActivation(projectId, runId)) {
       trackEvent("activation.completed", {
         flowVersion: ONBOARDING_FLOW_VERSION,
@@ -9350,10 +9443,10 @@ var JobRunner = class {
   /**
    * Read an ended batch's results into its run: every line mapped by
    * `custom_id` to its slot, parsed by the adapter's own parser and recorded
-   * through `recordSlot`, exactly like a sync answer but at the batch tier.
+   * through the shared slot preparation, like a sync answer at the batch tier.
    *
-   * Idempotent across crashes. Each line's outcome is written as soon as it is
-   * handled and a handled line is skipped on the next pass; the insert does
+   * Idempotent across crashes. Bounded chunks commit each snapshot together
+   * with its outcome; handled lines are skipped on the next pass. The insert does
    * nothing on a slot that is already answered; the reservation of unbilled
    * lines is released under `quota_released`, in the same transaction that
    * marks the batch `ingested`. Answers are scored against the project's
@@ -9375,30 +9468,74 @@ var JobRunner = class {
     const requests = new Map(this.db.select().from(providerBatchRequests).where(eq3(providerBatchRequests.batchId, batch.id)).all().map((row) => [row.id, row]));
     const ctx = { ...this.buildRunRecordingContext(batch.runId, batch.projectId), onInserted: () => {
     } };
+    const pending = [];
+    let pendingBytes = 0;
+    const queued = /* @__PURE__ */ new Set();
+    const flush = () => {
+      if (pending.length === 0) return true;
+      const chunk = pending.splice(0);
+      pendingBytes = 0;
+      const settled = this.persistBatchLines(batch, chunk);
+      if (!settled) return false;
+      for (const result2 of settled) {
+        const request = requests.get(result2.line.requestId);
+        requests.set(request.id, { ...request, outcome: result2.outcome, error: result2.line.error });
+        result2.line.slot?.report(result2.inserted);
+        result2.line.report?.();
+      }
+      queued.clear();
+      return true;
+    };
     try {
+      let linesSinceYield = 0;
       for await (const line of capability.results(batch.providerBatchId, registered.config)) {
+        if (linesSinceYield === BATCH_INGEST_CHUNK_SIZE) {
+          await yieldToEventLoop();
+          linesSinceYield = 0;
+        }
+        linesSinceYield++;
         const request = requests.get(line.customId);
         if (!request) {
           log2.warn("batch.unknown-line", { batchId: batch.id, provider: batch.provider, customId: line.customId });
           continue;
         }
-        if (request.outcome !== null) continue;
-        if (this.db.select({ status: providerBatches.status }).from(providerBatches).where(eq3(providerBatches.id, batch.id)).get()?.status !== ProviderBatchStatuses.ended) {
-          return { kind: "cancelled" };
+        if (request.outcome !== null || queued.has(request.id)) continue;
+        if (this.db.select({ status: providerBatches.status }).from(providerBatches).where(eq3(providerBatches.id, batch.id)).get()?.status !== ProviderBatchStatuses.ended) return { kind: "cancelled" };
+        const prepared = await this.prepareBatchLine(ctx, registered, batch, request, line);
+        const payloadBytes = Buffer.byteLength(prepared.slot?.snapshot.rawResponse ?? "") + Buffer.byteLength(prepared.slot?.snapshot.answerText ?? "") + Buffer.byteLength(prepared.error ?? "");
+        if (pending.length > 0 && pendingBytes + payloadBytes > BATCH_INGEST_PAYLOAD_BYTES) {
+          if (!flush()) return { kind: "cancelled" };
+          await yieldToEventLoop();
+          linesSinceYield = 0;
+        }
+        pending.push(prepared);
+        pendingBytes += payloadBytes;
+        queued.add(request.id);
+        if (pending.length === BATCH_INGEST_CHUNK_SIZE || pendingBytes >= BATCH_INGEST_PAYLOAD_BYTES) {
+          if (!flush()) return { kind: "cancelled" };
+          await yieldToEventLoop();
+          linesSinceYield = 0;
         }
-        const settled = await this.ingestBatchLine(ctx, registered, batch, request, line);
-        this.db.update(providerBatchRequests).set({ outcome: settled.outcome, error: settled.error }).where(and3(eq3(providerBatchRequests.id, request.id), isNull(providerBatchRequests.outcome))).run();
-        requests.set(request.id, { ...request, outcome: settled.outcome });
       }
+      if (!flush()) return { kind: "cancelled" };
     } catch (err) {
-      if (!(err instanceof RunCancelledError)) throw err;
+      let failure2 = err;
+      if (!(failure2 instanceof RunCancelledError)) {
+        try {
+          if (!flush()) return { kind: "cancelled" };
+        } catch (flushError) {
+          failure2 = flushError;
+        }
+      }
+      if (!(failure2 instanceof RunCancelledError)) throw failure2;
       this.markBatchesCancelled([batch.id], "Cancelled because its run is no longer running.");
       return { kind: "cancelled" };
     }
     return this.completeBatchIngest(batch);
   }
-  async ingestBatchLine(ctx, registered, batch, request, line) {
-    if (line.type !== "succeeded") return { outcome: unansweredOutcome(line.type), error: line.error };
+  async prepareBatchLine(ctx, registered, batch, request, line) {
+    const base = { requestId: request.id, slot: null };
+    if (line.type !== "succeeded") return { ...base, outcome: unansweredOutcome(line.type), error: line.error };
     const { adapter } = registered;
     if (!adapter.parseTrackedQueryResponse) throw new Error(`Provider ${adapter.name} cannot read a batch answer`);
     let raw;
@@ -9406,34 +9543,67 @@ var JobRunner = class {
       raw = adapter.parseTrackedQueryResponse(line.body, resolveProviderModel(adapter.name, request.requestedModel));
     } catch (err) {
       const error = describeError(err);
-      log2.warn("batch.parse-failed", { runId: batch.runId, batchId: batch.id, provider: batch.provider, executionId: request.executionId, error });
-      return { outcome: ProviderBatchRequestOutcomes.parse_failed, error };
+      return {
+        ...base,
+        outcome: ProviderBatchRequestOutcomes.parse_failed,
+        error,
+        report: () => log2.warn("batch.parse-failed", { runId: batch.runId, batchId: batch.id, provider: batch.provider, executionId: request.executionId, error })
+      };
     }
-    const unit = {
+    const slot = await this.prepareSlot(ctx, registered, {
       executionId: request.executionId,
       queryText: request.queryText,
       context: request.requestedContext,
       queryId: request.queryId,
       requestedModel: request.requestedModel
-    };
-    const written = await this.recordSlot(ctx, registered, unit, raw, {
+    }, raw, {
       idempotent: true,
       mode: ProviderDispatchModes.batch,
       providerBatchId: batch.id,
       pricingTier: PricingTiers.batch
     });
-    if (written) return { outcome: ProviderBatchRequestOutcomes.recorded, error: null };
-    const existing = this.db.select({ providerBatchId: querySnapshots.providerBatchId }).from(querySnapshots).where(and3(
-      eq3(querySnapshots.runId, batch.runId),
-      eq3(querySnapshots.measurementExecutionId, request.executionId),
-      eq3(querySnapshots.provider, registered.adapter.name)
-    )).get();
-    return existing?.providerBatchId === batch.id ? { outcome: ProviderBatchRequestOutcomes.recorded, error: null } : { outcome: ProviderBatchRequestOutcomes.duplicate, error: null };
+    return { requestId: request.id, slot, outcome: ProviderBatchRequestOutcomes.recorded, error: null };
+  }
+  /** Snapshots and their replay ledger commit together, with no callbacks or awaits. */
+  persistBatchLines(batch, lines) {
+    return this.db.transaction((tx) => {
+      if (tx.select({ status: providerBatches.status }).from(providerBatches).where(eq3(providerBatches.id, batch.id)).get()?.status !== ProviderBatchStatuses.ended) return null;
+      if (tx.select({ status: runs.status }).from(runs).where(eq3(runs.id, batch.runId)).get()?.status !== RunStatuses.running) throw new RunCancelledError(batch.runId);
+      const current = new Map(tx.select({
+        id: providerBatchRequests.id,
+        outcome: providerBatchRequests.outcome,
+        queryId: providerBatchRequests.queryId,
+        executionId: providerBatchRequests.executionId
+      }).from(providerBatchRequests).where(inArray(providerBatchRequests.id, lines.map((line) => line.requestId))).all().map((row) => [row.id, row]));
+      const settled = [];
+      for (const line of lines) {
+        const request = current.get(line.requestId);
+        if (!request || request.outcome !== null) continue;
+        current.delete(line.requestId);
+        let outcome = line.outcome;
+        let inserted = false;
+        if (line.slot) {
+          const snapshot = { ...line.slot.snapshot, queryId: request.queryId };
+          inserted = tx.insert(querySnapshots).values(snapshot).onConflictDoNothing().run().changes > 0;
+          if (!inserted) {
+            const existing = tx.select({ providerBatchId: querySnapshots.providerBatchId }).from(querySnapshots).where(and3(
+              eq3(querySnapshots.runId, batch.runId),
+              eq3(querySnapshots.measurementExecutionId, request.executionId),
+              eq3(querySnapshots.provider, batch.provider)
+            )).get();
+            outcome = existing?.providerBatchId === batch.id ? ProviderBatchRequestOutcomes.recorded : ProviderBatchRequestOutcomes.duplicate;
+          }
+        }
+        tx.update(providerBatchRequests).set({ outcome, error: line.error }).where(and3(eq3(providerBatchRequests.id, request.id), isNull(providerBatchRequests.outcome))).run();
+        settled.push({ line, outcome, inserted });
+      }
+      return settled;
+    }, { behavior: "immediate" });
   }
   /** Close an ingest: counts, the unbilled lines' quota, and `ingested`, in one transaction. */
   completeBatchIngest(batch) {
     const at = (/* @__PURE__ */ new Date()).toISOString();
-    return this.db.transaction((tx) => {
+    const result2 = this.db.transaction((tx) => {
       const txDb = tx;
       const current = txDb.select().from(providerBatches).where(eq3(providerBatches.id, batch.id)).get();
       if (current?.status !== ProviderBatchStatuses.ended) return { kind: "skipped" };
@@ -9449,9 +9619,19 @@ var JobRunner = class {
         updatedAt: at
       }).where(and3(eq3(providerBatches.id, batch.id), eq3(providerBatches.status, ProviderBatchStatuses.ended))).run();
       const { recordedCount: recorded, notRecorded } = tally;
-      log2.info("batch.ingested", { runId: batch.runId, batchId: batch.id, provider: batch.provider, recorded, notRecorded, released });
       return { kind: "ingested", recorded, notRecorded, released };
     });
+    if (result2.kind === "ingested") {
+      log2.info("batch.ingested", {
+        runId: batch.runId,
+        batchId: batch.id,
+        provider: batch.provider,
+        recorded: result2.recorded,
+        notRecorded: result2.notRecorded,
+        released: result2.released
+      });
+    }
+    return result2;
   }
   /**
    * Give up on an ended batch whose results cannot be read in time. It
@@ -9742,6 +9922,15 @@ var JobRunner = class {
    * writes nothing and resolves false.
    */
   async recordSlot(ctx, registeredProvider, unit, raw, dispatch) {
+    const prepared = await this.prepareSlot(ctx, registeredProvider, unit, raw, dispatch);
+    this.throwIfRunCancelled(ctx.runId);
+    const insert = this.db.insert(querySnapshots).values(prepared.snapshot);
+    const written = ctx.fill || dispatch.idempotent ? insert.onConflictDoNothing().run() : insert.run();
+    prepared.report(written.changes > 0);
+    return written.changes > 0;
+  }
+  /** Resolve network/file evidence and derived fields before opening a write transaction. */
+  async prepareSlot(ctx, registeredProvider, unit, raw, dispatch) {
     const { adapter } = registeredProvider;
     const providerName = adapter.name;
     const { domains: competitorDomains, aliases: competitorAliases } = ctx.competitorsFor(unit.executionId);
@@ -9798,7 +9987,7 @@ var JobRunner = class {
       fs4.renameSync(raw.screenshotPath, destPath);
       screenshotRelPath = `${ctx.runId}/${snapshotId}.png`;
     }
-    const insert = this.db.insert(querySnapshots).values({
+    const snapshot = {
       id: snapshotId,
       runId: ctx.runId,
       queryId: unit.queryId,
@@ -9850,20 +10039,23 @@ var JobRunner = class {
         overrides: registeredProvider.config.pricing
       }),
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    const written = ctx.fill || dispatch.idempotent ? insert.onConflictDoNothing().run() : insert.run();
-    if (written.changes > 0) ctx.onInserted();
-    ctx.fill?.onOutcome(providerName, true);
-    log2.info("query.citation", {
-      runId: ctx.runId,
-      provider: providerName,
-      query: unit.queryText,
-      executionId: unit.executionId,
-      location: requestedContext?.label ?? null,
-      citationState,
-      answerMentioned
-    });
-    return written.changes > 0;
+    };
+    return {
+      snapshot,
+      report: (inserted) => {
+        if (inserted) ctx.onInserted();
+        ctx.fill?.onOutcome(providerName, true);
+        log2.info("query.citation", {
+          runId: ctx.runId,
+          provider: providerName,
+          query: unit.queryText,
+          executionId: unit.executionId,
+          location: requestedContext?.label ?? null,
+          citationState,
+          answerMentioned
+        });
+      }
+    };
   }
   /**
    * Rebuild a run's recording identity from the database, for a path that
@@ -9906,6 +10098,36 @@ var JobRunner = class {
     }
     providerReservations.clear();
   }
+  /**
+   * How many runs of the same kind, created before this one, failed or came
+   * back partial in a row. Telemetry only: it feeds `failureStreak` and the
+   * sampling of runs stuck failing the same way. Probes do not count, other run
+   * kinds (syncs, audits) neither break nor extend a streak, and a run aborted
+   * before any provider was called (`run.aborted`, never a failed
+   * `run.completed`) is skipped, so every failure counted was also reported.
+   */
+  priorFailureStreak(projectId, currentRunId) {
+    try {
+      const current = this.db.select({ kind: runs.kind, createdAt: runs.createdAt }).from(runs).where(eq3(runs.id, currentRunId)).get();
+      if (!current) return 0;
+      const recent = this.db.select({ status: runs.status, error: runs.error }).from(runs).where(and3(
+        eq3(runs.projectId, projectId),
+        eq3(runs.kind, current.kind),
+        lt(runs.createdAt, current.createdAt),
+        ne(runs.trigger, RunTriggers.probe),
+        inArray(runs.status, ["completed", "partial", "failed"])
+      )).orderBy(desc(runs.createdAt)).limit(FAILURE_STREAK_LOOKBACK).all();
+      let streak = 0;
+      for (const row of recent) {
+        if (row.status === "completed") break;
+        if (row.status === "failed" && row.error && classifyRunAbortReason(row.error)) continue;
+        streak++;
+      }
+      return streak;
+    } catch {
+      return 0;
+    }
+  }
   hasPriorActivation(projectId, currentRunId) {
     return this.db.select({ id: querySnapshots.id }).from(querySnapshots).innerJoin(runs, eq3(querySnapshots.runId, runs.id)).where(and3(
       eq3(runs.projectId, projectId),
@@ -9997,7 +10219,7 @@ import { eq as eq5, and as and5, sql as sql3 } from "drizzle-orm";
 
 // src/gsc-coverage-snapshot.ts
 import crypto7 from "crypto";
-import { and as and4, desc, eq as eq4, gte } from "drizzle-orm";
+import { and as and4, desc as desc2, eq as eq4, gte } from "drizzle-orm";
 var COVERAGE_IMPRESSION_WINDOW_DAYS = 30;
 function pageKey(raw) {
   if (!raw) return null;
@@ -10021,9 +10243,9 @@ function writeCoverageSnapshot(db, projectId, runId, opts = {}) {
     eq4(siteCrawlSnapshots.projectId, projectId),
     eq4(siteCrawlSnapshots.complete, true),
     eq4(runs.status, "completed")
-  )).orderBy(desc(siteCrawlSnapshots.createdAt)).limit(1).get();
+  )).orderBy(desc2(siteCrawlSnapshots.createdAt)).limit(1).get();
   const hasCrawlHistory = Boolean(db.select({ id: siteCrawlSnapshots.id }).from(siteCrawlSnapshots).where(eq4(siteCrawlSnapshots.projectId, projectId)).limit(1).get());
-  const latestAudit = db.select({ runId: siteAuditSnapshots.runId }).from(siteAuditSnapshots).where(eq4(siteAuditSnapshots.projectId, projectId)).orderBy(desc(siteAuditSnapshots.createdAt)).limit(1).get();
+  const latestAudit = db.select({ runId: siteAuditSnapshots.runId }).from(siteAuditSnapshots).where(eq4(siteAuditSnapshots.projectId, projectId)).orderBy(desc2(siteAuditSnapshots.createdAt)).limit(1).get();
   const sitemapUrls = latestCrawl?.attemptId ? db.select({ url: siteCrawlPages.url }).from(siteCrawlPages).where(and4(
     eq4(siteCrawlPages.projectId, projectId),
     eq4(siteCrawlPages.runId, latestCrawl.runId),
@@ -10244,11 +10466,11 @@ async function executeGscSync(db, runId, projectId, opts) {
 
 // src/gbp-sync.ts
 import crypto10 from "crypto";
-import { eq as eq7, and as and7, desc as desc3, inArray as inArray3, lt } from "drizzle-orm";
+import { eq as eq7, and as and7, desc as desc4, inArray as inArray3, lt as lt2 } from "drizzle-orm";
 
 // src/gbp-reviews.ts
 import crypto9 from "crypto";
-import { and as and6, desc as desc2, eq as eq6, inArray as inArray2, sql as sql4 } from "drizzle-orm";
+import { and as and6, desc as desc3, eq as eq6, inArray as inArray2, sql as sql4 } from "drizzle-orm";
 var log4 = createLogger("GbpReviews");
 var MS_PER_DAY = 864e5;
 var REVIEW_ALERT_MAX_AGE_DAYS = 30;
@@ -10280,7 +10502,7 @@ function placesReviewsDue(db, projectId, locationName, now) {
     eq6(gbpReviewRatings.projectId, projectId),
     eq6(gbpReviewRatings.locationName, locationName),
     eq6(gbpReviewRatings.origin, "places")
-  )).orderBy(desc2(gbpReviewRatings.observedAt)).limit(1).get();
+  )).orderBy(desc3(gbpReviewRatings.observedAt)).limit(1).get();
   if (!latest) return true;
   return now.getTime() - Date.parse(latest.observedAt) >= PLACES_REVIEW_MIN_INTERVAL_HOURS * 36e5;
 }
@@ -10361,7 +10583,7 @@ function persistReviewObservation(tx, projectId, runId, obs, ctx) {
     eq6(gbpReviewRatings.projectId, projectId),
     eq6(gbpReviewRatings.locationName, obs.locationName),
     eq6(gbpReviewRatings.origin, obs.origin)
-  )).orderBy(desc2(gbpReviewRatings.observedAt)).limit(1).get();
+  )).orderBy(desc3(gbpReviewRatings.observedAt)).limit(1).get();
   const baseline = latestRating === void 0;
   let queuedRatingDrop = false;
   if (!latestRating) {
@@ -10567,15 +10789,15 @@ async function executeGbpSync(db, runId, projectId, opts) {
             fetchLocationReviews(db, projectId, loc, reviewContext)
           ]);
           const lodgingHash = lodging ? hashLodging(lodging) : null;
-          const latestLodging = lodging ? db.select().from(gbpLodgingSnapshots).where(and7(eq7(gbpLodgingSnapshots.projectId, projectId), eq7(gbpLodgingSnapshots.locationName, loc.locationName))).orderBy(desc3(gbpLodgingSnapshots.syncedAt)).limit(1).get() : void 0;
+          const latestLodging = lodging ? db.select().from(gbpLodgingSnapshots).where(and7(eq7(gbpLodgingSnapshots.projectId, projectId), eq7(gbpLodgingSnapshots.locationName, loc.locationName))).orderBy(desc4(gbpLodgingSnapshots.syncedAt)).limit(1).get() : void 0;
           const lodgingChanged = lodging !== null && latestLodging?.contentHash !== lodgingHash;
           const attributesHash = hashAttributes(attributes);
-          const latestAttributes = db.select().from(gbpAttributesSnapshots).where(and7(eq7(gbpAttributesSnapshots.projectId, projectId), eq7(gbpAttributesSnapshots.locationName, loc.locationName))).orderBy(desc3(gbpAttributesSnapshots.syncedAt)).limit(1).get();
+          const latestAttributes = db.select().from(gbpAttributesSnapshots).where(and7(eq7(gbpAttributesSnapshots.projectId, projectId), eq7(gbpAttributesSnapshots.locationName, loc.locationName))).orderBy(desc4(gbpAttributesSnapshots.syncedAt)).limit(1).get();
           const attributesChanged = latestAttributes?.contentHash !== attributesHash;
           let placeToWrite = null;
           let placeToTouch = null;
           if (placesTier !== "off" && placesApiKey && lodging !== null && loc.placeId) {
-            const latestPlace = db.select().from(gbpPlaceDetails).where(and7(eq7(gbpPlaceDetails.projectId, projectId), eq7(gbpPlaceDetails.locationName, loc.locationName))).orderBy(desc3(gbpPlaceDetails.syncedAt)).limit(1).get();
+            const latestPlace = db.select().from(gbpPlaceDetails).where(and7(eq7(gbpPlaceDetails.projectId, projectId), eq7(gbpPlaceDetails.locationName, loc.locationName))).orderBy(desc4(gbpPlaceDetails.syncedAt)).limit(1).get();
             const ageDays = latestPlace ? (Date.now() - new Date(latestPlace.syncedAt).getTime()) / MS_PER_DAY2 : Infinity;
             if (ageDays >= placesRefreshDays) {
               try {
@@ -10645,7 +10867,7 @@ async function executeGbpSync(db, runId, projectId, opts) {
               tx.delete(gbpKeywordMonthly).where(and7(
                 eq7(gbpKeywordMonthly.projectId, projectId),
                 eq7(gbpKeywordMonthly.locationName, loc.locationName),
-                lt(gbpKeywordMonthly.month, keywordRetentionCutoff)
+                lt2(gbpKeywordMonthly.month, keywordRetentionCutoff)
               )).run();
             }
             tx.delete(gbpPlaceActions).where(and7(eq7(gbpPlaceActions.projectId, projectId), eq7(gbpPlaceActions.locationName, loc.locationName))).run();
@@ -11973,7 +12195,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
 
 // src/bing-inspect-sitemap.ts
 import crypto14 from "crypto";
-import { eq as eq10, desc as desc4 } from "drizzle-orm";
+import { eq as eq10, desc as desc5 } from "drizzle-orm";
 var log9 = createLogger("BingInspectSitemap");
 var BING_INSPECT_SPACING_MS = 2e3;
 function parseBingDate(value) {
@@ -12137,7 +12359,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         `Bing inspection failed for every URL attempted (${errors} of ${targetUrls.length}); coverage was left unchanged rather than re-dated from stored inspections. Last error: ${detail}`
       );
     }
-    const allInspections = db.select().from(bingUrlInspections).where(eq10(bingUrlInspections.projectId, projectId)).orderBy(desc4(bingUrlInspections.inspectedAt)).all();
+    const allInspections = db.select().from(bingUrlInspections).where(eq10(bingUrlInspections.projectId, projectId)).orderBy(desc5(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -12203,7 +12425,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
 
 // src/coverage-refresh.ts
 import crypto15 from "crypto";
-import { and as and9, desc as desc5, eq as eq11, inArray as inArray5 } from "drizzle-orm";
+import { and as and9, desc as desc6, eq as eq11, inArray as inArray5 } from "drizzle-orm";
 var log10 = createLogger("CoverageRefresh");
 var COVERAGE_REFRESH_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 var COVERAGE_REFRESH_MANUAL_MIN_INTERVAL_MS = 2 * 60 * 1e3;
@@ -12232,7 +12454,7 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
       eq11(runs.kind, RunKinds["inspect-sitemap"]),
       inArray5(runs.status, IN_FLIGHT_STATUSES)
     )
-  ).orderBy(desc5(runs.createdAt)).limit(1).get();
+  ).orderBy(desc6(runs.createdAt)).limit(1).get();
   if (inFlight2) {
     log10.info("skip.in-flight", { projectId });
     return null;
@@ -12244,7 +12466,7 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
       eq11(runs.kind, RunKinds["inspect-sitemap"]),
       inArray5(runs.status, ACTIVE_OR_DONE_STATUSES)
     )
-  ).orderBy(desc5(runs.createdAt)).limit(1).get();
+  ).orderBy(desc6(runs.createdAt)).limit(1).get();
   if (recent) {
     const ageMs = nowMs - Date.parse(recent.createdAt);
     if (Number.isFinite(ageMs) && ageMs < windowMs) {
@@ -12469,7 +12691,7 @@ function computeSummary(rows) {
 // src/backlink-extract.ts
 import crypto17 from "crypto";
 import fs5 from "fs";
-import { and as and11, desc as desc6, eq as eq13 } from "drizzle-orm";
+import { and as and11, desc as desc7, eq as eq13 } from "drizzle-orm";
 var log12 = createLogger("BacklinkExtract");
 function defaultDeps3() {
   return {
@@ -12487,7 +12709,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq13(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq13(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc6(ccReleaseSyncs.createdAt)).limit(1).get();
+    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq13(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq13(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc7(ccReleaseSyncs.createdAt)).limit(1).get();
     if (!sync) {
       throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
     }
@@ -13391,10 +13613,13 @@ function deadLinkCheckedCount(edges, pages) {
 }
 function trackSiteAuditOutcome(db, input) {
   try {
-    const errorCode = input.status === "cancelled" ? "RUN_CANCELLED" : input.status === "failed" ? "UNKNOWN" : void 0;
+    const errorCode = input.status === "cancelled" ? "RUN_CANCELLED" : input.status === "failed" ? "INTERNAL" : void 0;
     trackEvent(
       "site_audit.completed",
-      buildSiteAuditCompletedProps(input),
+      {
+        ...buildSiteAuditCompletedProps(input),
+        ...input.status === "failed" ? describeRunFailure(input.error) : {}
+      },
       errorCode ? { errorCode } : void 0
     );
     const pagesAudited = input.crawl?.pagesAudited ?? 0;
@@ -13961,15 +14186,18 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       status: cancelled ? "cancelled" : "failed",
       startTime,
       trigger,
-      canonicalDomain
+      canonicalDomain,
+      error
     });
     throw error;
   }
 }
 
 // src/commands/backfill.ts
-import { and as and15, eq as eq17, inArray as inArray7, isNull as isNull2, sql as sql7 } from "drizzle-orm";
+import { setImmediate as yieldToEventLoop2 } from "timers/promises";
+import { and as and15, asc as asc4, desc as desc8, eq as eq17, gt as gt3, inArray as inArray7, isNull as isNull2, lte as lte2, sql as sql7 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
+var PATH_REPAIR_PAGE_SIZE = 128;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
   const db = createClient(config.database);
@@ -14150,35 +14378,54 @@ No DB writes performed. Re-run without --dry-run to apply.`);
   }
 }
 function backfillNormalizedPaths(db, opts) {
-  const baseConditions = [];
-  if (opts?.projectId) {
-    baseConditions.push(eq17(gaTrafficSnapshots.projectId, opts.projectId));
-  }
-  const rows = db.select({
-    id: gaTrafficSnapshots.id,
-    landingPage: gaTrafficSnapshots.landingPage,
-    landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and15(...baseConditions) : void 0).all();
+  return repairStoredPaths(db, gaTrafficSnapshots, opts);
+}
+async function repairStoredPaths(db, table, opts) {
+  const pageSize = opts?.pageSize ?? PATH_REPAIR_PAGE_SIZE;
+  const projectScope = opts?.projectId ? sql7`+${table.projectId} = ${opts.projectId}` : void 0;
+  const lastId = db.select({ id: table.id }).from(table).where(projectScope).orderBy(desc8(table.id)).limit(1).get()?.id;
+  if (lastId === void 0) return { examined: 0, updated: 0, unchanged: 0 };
+  let cursor;
+  let examined = 0;
   let updated = 0;
-  let unchanged = 0;
-  if (rows.length > 0) {
-    db.transaction((tx) => {
-      for (const row of rows) {
-        const next = normalizeUrlPath(row.landingPage);
-        if (next === null) {
-          unchanged++;
-          continue;
-        }
-        if (row.landingPageNormalized === next) {
-          unchanged++;
-          continue;
-        }
-        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq17(gaTrafficSnapshots.id, row.id)).run();
-        updated++;
-      }
+  for (; ; ) {
+    const rows = db.select({
+      id: table.id,
+      projectId: table.projectId,
+      landingPage: table.landingPage,
+      landingPageNormalized: table.landingPageNormalized
+    }).from(table).where(and15(
+      projectScope,
+      lte2(table.id, lastId),
+      cursor === void 0 ? void 0 : gt3(table.id, cursor)
+    )).orderBy(asc4(table.id)).limit(pageSize).all();
+    examined += rows.length;
+    const changes = rows.flatMap((row) => {
+      const next = normalizeUrlPath(row.landingPage);
+      return next === null || row.landingPageNormalized === next ? [] : [{ row, next }];
     });
+    if (changes.length > 0) {
+      const written = db.transaction((tx) => {
+        let written2 = 0;
+        for (const { row, next } of changes) {
+          written2 += tx.update(table).set({ landingPageNormalized: next }).where(and15(
+            eq17(table.id, row.id),
+            eq17(table.projectId, row.projectId),
+            eq17(table.landingPage, row.landingPage),
+            row.landingPageNormalized === null ? isNull2(table.landingPageNormalized) : eq17(table.landingPageNormalized, row.landingPageNormalized)
+          )).run().changes;
+        }
+        return written2;
+      });
+      updated += written;
+      if (written < changes.length) opts?.onConflict?.();
+    }
+    if (rows.length < pageSize) break;
+    cursor = rows.at(-1).id;
+    if (cursor === lastId) break;
+    await yieldToEventLoop2();
   }
-  return { examined: rows.length, updated, unchanged };
+  return { examined, updated, unchanged: examined - updated };
 }
 async function backfillNormalizedPathsCommand(opts) {
   const config = loadConfig();
@@ -14204,7 +14451,7 @@ async function backfillNormalizedPathsCommand(opts) {
     }
     projectId = project.id;
   }
-  const { examined, updated, unchanged } = backfillNormalizedPaths(db, { projectId });
+  const { examined, updated, unchanged } = await backfillNormalizedPaths(db, { projectId });
   const result2 = {
     project: projectFilter ?? null,
     examined,
@@ -14222,35 +14469,7 @@ async function backfillNormalizedPathsCommand(opts) {
   console.log(`  Unchanged: ${unchanged}`);
 }
 function backfillAiReferralPaths(db, opts) {
-  const baseConditions = [];
-  if (opts?.projectId) {
-    baseConditions.push(eq17(gaAiReferrals.projectId, opts.projectId));
-  }
-  const rows = db.select({
-    id: gaAiReferrals.id,
-    landingPage: gaAiReferrals.landingPage,
-    landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and15(...baseConditions) : void 0).all();
-  let updated = 0;
-  let unchanged = 0;
-  if (rows.length > 0) {
-    db.transaction((tx) => {
-      for (const row of rows) {
-        const next = normalizeUrlPath(row.landingPage);
-        if (next === null) {
-          unchanged++;
-          continue;
-        }
-        if (row.landingPageNormalized === next) {
-          unchanged++;
-          continue;
-        }
-        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq17(gaAiReferrals.id, row.id)).run();
-        updated++;
-      }
-    });
-  }
-  return { examined: rows.length, updated, unchanged };
+  return repairStoredPaths(db, gaAiReferrals, opts);
 }
 async function backfillAiReferralPathsCommand(opts) {
   const config = loadConfig();
@@ -14276,7 +14495,7 @@ async function backfillAiReferralPathsCommand(opts) {
     }
     projectId = project.id;
   }
-  const { examined, updated, unchanged } = backfillAiReferralPaths(db, { projectId });
+  const { examined, updated, unchanged } = await backfillAiReferralPaths(db, { projectId });
   const result2 = {
     project: projectFilter ?? null,
     examined,
@@ -14454,7 +14673,7 @@ function readStoredGroundingSources(rawResponse) {
   return result2;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-QUAOWEIA.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-4IONMOFB.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -15871,7 +16090,7 @@ async function refreshAllIntegrations(client, projectName, now = /* @__PURE__ */
 }
 
 // src/notifier.ts
-import { eq as eq20, desc as desc7, and as and18, inArray as inArray10, or } from "drizzle-orm";
+import { eq as eq20, desc as desc9, and as and18, inArray as inArray10, or } from "drizzle-orm";
 import crypto21 from "crypto";
 var log19 = createLogger("Notifier");
 var MATERIAL_MAGNITUDE_DELTA = 20;
@@ -16412,7 +16631,7 @@ var Notifier = class {
         eq20(runs.kind, thisRun.kind),
         or(eq20(runs.status, "completed"), eq20(runs.status, "partial"))
       )
-    ).orderBy(desc7(runs.createdAt), desc7(runs.id)).limit(RECENT_FETCH_LIMIT).all();
+    ).orderBy(desc9(runs.createdAt), desc9(runs.id)).limit(RECENT_FETCH_LIMIT).all();
     const groups = groupRunsByCreatedAt(recentRuns);
     const currentGroupIdx = groups.findIndex((g) => g[0]?.createdAt === thisRun.createdAt);
     if (currentGroupIdx < 0) return [];
@@ -16733,12 +16952,17 @@ var PROVIDER_MODELS = {
     [LlmCapabilities.classify]: "gpt-5-nano"
   },
   [AgentProviderIds.gemini]: {
-    // Gemini's 2.5-flash is already cheap + capable; flash-lite is the
+    // Gemini's Flash is already cheap + capable; Flash-Lite is the
     // dedicated micro tier for classify. Analyze stays on flash because
     // flash-lite drops too much quality for structured synthesis.
-    [LlmCapabilities.agent]: "gemini-2.5-flash",
-    [LlmCapabilities.analyze]: "gemini-2.5-flash",
-    [LlmCapabilities.classify]: "gemini-2.5-flash-lite"
+    // Exact IDs, never Google's `-latest` aliases: pi-ai derives request
+    // options (thinking level) from the catalog entry for the ID it is given,
+    // and an alias entry can lag the model it serves. `gemini-flash-latest`
+    // allows MINIMAL thinking while the 3.8 Flash it resolves to rejects it,
+    // so every Aero turn failed. Sweeps can use the alias; Aero cannot.
+    [LlmCapabilities.agent]: "gemini-3.8-flash",
+    [LlmCapabilities.analyze]: "gemini-3.8-flash",
+    [LlmCapabilities.classify]: "gemini-3.5-flash-lite"
   },
   [AgentProviderIds.zai]: {
     // GLM lineage: 5.2 replaced 5.1, which pi-ai 0.87 dropped from its
@@ -18631,7 +18855,7 @@ async function loadExternalMcpTools(servers, opts = {}) {
 
 // src/agent/memory-store.ts
 import crypto24 from "crypto";
-import { and as and19, desc as desc8, eq as eq22, like, sql as sql10, or as or2 } from "drizzle-orm";
+import { and as and19, desc as desc10, eq as eq22, like, sql as sql10, or as or2 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -18645,7 +18869,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq22(agentMemory.projectId, projectId)).orderBy(desc8(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq22(agentMemory.projectId, projectId)).orderBy(desc10(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -18691,7 +18915,7 @@ function loadRecentForHydrate(db, projectId, limit, sessionId) {
   return db.select().from(agentMemory).where(and19(
     eq22(agentMemory.projectId, projectId),
     or2(sql10`substr(${agentMemory.key}, 1, ${COMPACTION_KEY_PREFIX.length}) <> ${COMPACTION_KEY_PREFIX}`, sessionId ? sql10`substr(${agentMemory.key}, 1, ${sessionPrefix.length}) = ${sessionPrefix}` : void 0)
-  )).orderBy(desc8(agentMemory.updatedAt)).limit(limit).all().map(rowToDto);
+  )).orderBy(desc10(agentMemory.updatedAt)).limit(limit).all().map(rowToDto);
 }
 function writeCompactionNote(db, args) {
   if (Buffer.byteLength(args.summary, "utf8") > AGENT_MEMORY_VALUE_MAX_BYTES) {
@@ -18719,7 +18943,7 @@ function writeCompactionNote(db, args) {
         eq22(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
-    ).orderBy(desc8(agentMemory.updatedAt)).all();
+    ).orderBy(desc10(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
       tx.delete(agentMemory).where(sql10`${agentMemory.id} IN (${sql10.join(stale.map((s) => sql10`${s}`), sql10`, `)})`).run();