@canonry/canonry 7.13.0 → 7.15.0

package/dist/{chunk-GQMSJEMZ.js → chunk-7HJYGDRW.js}

@@ -30,6 +30,7 @@ import {
   AdsOperationStepStates,
   AdsReconcileStrategies,
   AdsReviewStatuses,
+  AiEngineLeadRateUnavailableReasons,
   AiReferralTrafficClasses,
   AppError,
   BacklinkSources,
@@ -223,7 +224,9 @@ import {
   agentProvidersResponseDtoSchema,
   aggregateHarvestedQueries,
   aggregateSentiment,
+  aiEngineForReferralSource,
   aiReferralClassCounts,
+  aiReferralEngineLabel,
   alreadyExists,
   answerProseForMentions,
   apiKeyDtoSchema,
@@ -465,6 +468,7 @@ import {
   internalError,
   intersectScopes,
   isBrowserProvider,
+  isGa4AiAssistantChannel,
   isLocationRedirectStatus,
   isNegativeReviewRating,
   isProviderAccountFailure,
@@ -685,6 +689,7 @@ import {
   resultsExportDtoSchema,
   retryAfterDelayMs,
   roundRatio,
+  runAdmissionDtoSchema,
   runCompletenessDtoSchema,
   runDetailDtoSchema,
   runDtoSchema,
@@ -820,7 +825,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-AU7OUDWR.js";
+} from "./chunk-KOBK4I5N.js";
 
 // src/intelligence-service.ts
 import { eq as eq87, desc as desc39, asc as asc17, and as and73, ne as ne16, or as or21, inArray as inArray35, gte as gte23, lte as lte20, isNull as isNull16, sql as sql32, exists as exists2 } from "drizzle-orm";
@@ -1274,6 +1279,12 @@ var runs = sqliteTable("runs", {
    * lose them; folded into `error` and cleared when the run finalizes.
    */
   pendingProviderErrors: text("pending_provider_errors", { mode: "json" }).$type(),
+  /**
+   * Providers this run does not call because each keeps failing on its
+   * account, with the failure streak that decided it, frozen at queue time
+   * (`providerAccountAdmission`). Null when it skips none.
+   */
+  skippedProviders: text("skipped_providers", { mode: "json" }).$type(),
   createdAt: text("created_at").notNull()
 }, (table) => [
   index("idx_runs_project").on(table.projectId),
@@ -8322,6 +8333,16 @@ var MIGRATION_VERSIONS = [
       `ALTER TABLE dashboard_sessions ADD COLUMN api_key_hash TEXT NOT NULL DEFAULT ''`,
       `ALTER TABLE dashboard_sessions ADD COLUMN password_fingerprint TEXT`
     ]
+  },
+  {
+    // Providers a run does not call because each keeps failing on its
+    // account, frozen at queue time. Nullable with no default: every existing
+    // run, and every run an older writer queues, skips none.
+    version: 175,
+    name: "runs-skipped-providers",
+    statements: [
+      `ALTER TABLE runs ADD COLUMN skipped_providers TEXT`
+    ]
   }
 ];
 var AERO_LEDGER_REBUILDS = [
@@ -17405,7 +17426,11 @@ function sliceFor(plan, params) {
 }
 function assertMeasurementRunStampable(db, params) {
   const stamp = measurementStamp(db, params);
-  resolveQueueDispatch(db, params, stamp);
+  const dispatch = resolveQueueDispatch(db, params, stamp);
+  if (params.dispatchMode === ProviderDispatchModes.batch) {
+    const admission = queueProviderAdmission(db, params, stamp, params.createdAt ?? (/* @__PURE__ */ new Date()).toISOString());
+    dispatchAfterProviderAdmission(params, dispatch, admission);
+  }
 }
 function resolveQueueDispatch(tx, params, stamp) {
   const trigger = stamp?.scope ? RunTriggers.probe : params.trigger ?? RunTriggers.manual;
@@ -17427,6 +17452,30 @@ function resolveQueueDispatch(tx, params, stamp) {
   }
   return resolution;
 }
+function dispatchAfterProviderAdmission(params, dispatch, admission) {
+  if (admission.refused) return dispatch;
+  const skippedProviders = admission.skipped;
+  const modes = Object.fromEntries(Object.entries(dispatch.modes).filter(([provider]) => !(provider in skippedProviders)));
+  if (params.dispatchMode === ProviderDispatchModes.batch && Object.keys(modes).length === 0) {
+    throw validationError(
+      `${batchDispatchRefusalMessage(dispatch.ineligible)} Held back after repeated account failures: ${Object.keys(skippedProviders).join(", ")}. Pass force to call those providers now.`,
+      { ineligible: dispatch.ineligible, skippedProviders }
+    );
+  }
+  return { ...dispatch, modes };
+}
+function queueProviderAdmission(db, params, stamp, now) {
+  return (params.kind ?? RunKinds["answer-visibility"]) === RunKinds["answer-visibility"] ? providerAccountAdmission(db, {
+    projectId: params.projectId,
+    trigger: stamp?.scope ? RunTriggers.probe : params.trigger ?? RunTriggers.manual,
+    force: params.force ?? false,
+    now,
+    providers: () => providersARunWouldCall(
+      stamp?.identity.providers ?? providerRoster(db, params),
+      params.runnableProviders
+    )
+  }) : { skipped: {} };
+}
 function providersARunWouldCall(roster, runnable) {
   const listed = normalizeProviders(roster);
   if (runnable == null) return listed;
@@ -17447,63 +17496,124 @@ function providerSettingsChangeCouldFix(action, diff) {
     return false;
   }
 }
-function providerAccountRefusal(db, params) {
-  if (params.force || params.trigger === RunTriggers.probe) return null;
+function heldProviderAccounts(db, params) {
+  const held = /* @__PURE__ */ new Map();
   const recent = db.select({
     id: runs.id,
     status: runs.status,
     error: runs.error,
     createdAt: runs.createdAt,
-    finishedAt: runs.finishedAt
+    finishedAt: runs.finishedAt,
+    skippedProviders: runs.skippedProviders
   }).from(runs).where(and11(
     eq17(runs.projectId, params.projectId),
     eq17(runs.kind, RunKinds["answer-visibility"]),
     inArray6(runs.status, [RunStatuses.completed, RunStatuses.partial, RunStatuses.failed, RunStatuses.cancelled])
   )).orderBy(desc7(runs.createdAt), desc7(runs.id)).limit(PROVIDER_ACCOUNT_LOOKBACK).all().map((run) => ({ ...run, providers: parseRunError(run.error)?.providers ?? {} }));
-  const withAccountFailure = recent.filter((run) => Object.values(run.providers).some((entry) => isProviderAccountFailure(entry.code)));
-  if (withAccountFailure.length < PROVIDER_ACCOUNT_FAILURE_STREAK) return null;
+  const entries = recent.flatMap((run) => Object.values(run.providers));
+  const withAccountFailure = recent.filter((run) => Object.values(run.providers).some((entry) => !entry.skipped && isProviderAccountFailure(entry.code)));
+  if (withAccountFailure.length < PROVIDER_ACCOUNT_FAILURE_STREAK && !entries.some((entry) => entry.skipped)) return held;
   const calling = normalizeProviders(params.providers());
-  if (calling.length === 0) return null;
+  if (calling.length === 0) return held;
   const answered2 = (runId, provider) => db.select({ id: querySnapshots.id }).from(querySnapshots).where(and11(eq17(querySnapshots.runId, runId), eq17(querySnapshots.provider, provider))).limit(1).get() !== void 0;
-  const streaks = /* @__PURE__ */ new Map();
+  const finished = (run) => Date.parse(run.finishedAt ?? run.createdAt);
+  const now = Date.parse(params.now);
   for (const provider of calling) {
     let count4 = 0;
-    let newest2 = null;
+    let newest = null;
     let oldest = null;
     let code = null;
+    let vouched = null;
+    let ended = false;
     for (const run of recent) {
       const entry = run.providers[provider];
       if (!entry) {
-        if (run.status !== RunStatuses.failed && answered2(run.id, provider)) return null;
+        if (run.status !== RunStatuses.failed && answered2(run.id, provider)) {
+          ended = true;
+          break;
+        }
+        continue;
+      }
+      if (entry.skipped) {
+        vouched = run.skippedProviders?.[provider] ?? null;
+        if (vouched) break;
         continue;
       }
-      if (!isProviderAccountFailure(entry.code)) return null;
-      newest2 ??= run;
+      if (!isProviderAccountFailure(entry.code)) {
+        ended = true;
+        break;
+      }
+      newest ??= run;
       code ??= entry.code;
       oldest = run;
       count4 += 1;
       if (count4 === PROVIDER_ACCOUNT_FAILURE_STREAK) break;
     }
-    if (count4 < PROVIDER_ACCOUNT_FAILURE_STREAK) return null;
-    streaks.set(provider, { newest: newest2, oldest, code });
+    if (ended) continue;
+    if (count4 < PROVIDER_ACCOUNT_FAILURE_STREAK && !vouched) continue;
+    const retryAfterMs = newest ? finished(newest) + PROVIDER_ACCOUNT_RETRY_HOURS * 36e5 : Date.parse(vouched.retryAfter);
+    if (!(now < retryAfterMs)) continue;
+    held.set(provider, {
+      code: code ?? vouched.code,
+      consecutiveRuns: PROVIDER_ACCOUNT_FAILURE_STREAK,
+      // A vouched streak began before the runs read here.
+      since: vouched ? vouched.since : oldest.createdAt,
+      latestRunId: newest?.id ?? vouched.latestRunId,
+      retryAfter: new Date(retryAfterMs).toISOString()
+    });
+  }
+  if (held.size === 0) return held;
+  const since = [...held.values()].map((streak) => streak.since).sort()[0];
+  const settingsChanges = db.select({ entityId: auditLog.entityId, action: auditLog.action, diff: auditLog.diff, createdAt: auditLog.createdAt }).from(auditLog).where(and11(eq17(auditLog.entityType, "provider"), inArray6(auditLog.entityId, [...held.keys()]), gt3(auditLog.createdAt, since))).all();
+  for (const change of settingsChanges) {
+    const streak = held.get(change.entityId ?? "");
+    if (streak && change.createdAt > streak.since && providerSettingsChangeCouldFix(change.action, change.diff)) {
+      held.delete(change.entityId);
+    }
   }
-  const finished = (run) => Date.parse(run.finishedAt ?? run.createdAt);
-  const newest = [...streaks.values()].map((streak) => streak.newest).sort((a, b) => finished(b) - finished(a))[0];
-  const retryAfterMs = finished(newest) + PROVIDER_ACCOUNT_RETRY_HOURS * 36e5;
-  if (Date.parse(params.now) >= retryAfterMs) return null;
-  const since = [...streaks.values()].map((streak) => streak.oldest.createdAt).sort()[0];
-  const settingsChanges = db.select({ entityId: auditLog.entityId, action: auditLog.action, diff: auditLog.diff, createdAt: auditLog.createdAt }).from(auditLog).where(and11(eq17(auditLog.entityType, "provider"), inArray6(auditLog.entityId, calling), gt3(auditLog.createdAt, since))).all();
-  const fixedSince = settingsChanges.some((change) => {
-    const streak = streaks.get(change.entityId ?? "");
-    return streak !== void 0 && change.createdAt > streak.oldest.createdAt && providerSettingsChangeCouldFix(change.action, change.diff);
-  });
-  if (fixedSince) return null;
+  return held;
+}
+function providerAccountFailures(held) {
+  const streaks = [...held.values()];
+  const newest = [...streaks].sort((a, b) => b.retryAfter.localeCompare(a.retryAfter))[0];
   return {
     consecutiveRuns: PROVIDER_ACCOUNT_FAILURE_STREAK,
-    latestRunId: newest.id,
-    since,
-    retryAfter: new Date(retryAfterMs).toISOString(),
-    providers: Object.fromEntries(calling.map((provider) => [provider, streaks.get(provider).code]))
+    latestRunId: newest.latestRunId,
+    since: streaks.map((streak) => streak.since).sort()[0],
+    // The first provider called again lets a run through.
+    retryAfter: streaks.map((streak) => streak.retryAfter).sort()[0],
+    providers: Object.fromEntries([...held].map(([provider, streak]) => [provider, streak.code]))
+  };
+}
+function providerAccountAdmission(db, params) {
+  if (params.force || params.trigger === RunTriggers.probe) return { skipped: {} };
+  let calling = null;
+  const providers = () => calling ??= normalizeProviders(params.providers());
+  const held = heldProviderAccounts(db, { projectId: params.projectId, now: params.now, providers });
+  if (held.size === 0) return { skipped: {} };
+  if (providers().every((provider) => held.has(provider))) return { refused: providerAccountFailures(held) };
+  return { skipped: Object.fromEntries(held) };
+}
+function sweepProviders(db, projectId, runnable, selection) {
+  const planProviders = activeRevisionProviders(db, projectId);
+  if (planProviders.length > 0) return providersARunWouldCall(planProviders, runnable);
+  const schedule = db.select({ providers: schedules.providers, enabled: schedules.enabled }).from(schedules).where(and11(eq17(schedules.projectId, projectId), eq17(schedules.kind, RunKinds["answer-visibility"]))).get();
+  const project = db.select({ providers: projects.providers }).from(projects).where(eq17(projects.id, projectId)).get();
+  return providersARunWouldCall(resolveRunProviderSelection({
+    requestedProviders: selection === RunTriggers.scheduled && schedule?.enabled ? schedule.providers : null,
+    projectProviders: project?.providers ?? [],
+    runnableProviders: runnable
+  }), runnable);
+}
+function runAdmissionState(db, params) {
+  let calling = null;
+  const providers = () => calling ??= sweepProviders(db, params.projectId, params.runnableProviders, params.selection ?? RunTriggers.scheduled);
+  const held = heldProviderAccounts(db, { projectId: params.projectId, now: params.now, providers });
+  const refused = held.size > 0 && providers().every((provider) => held.has(provider));
+  return {
+    refused,
+    retryAfter: refused ? providerAccountFailures(held).retryAfter : null,
+    providers: Object.fromEntries(held)
   };
 }
 function providersFailingError(projectName, failures) {
@@ -17513,6 +17623,20 @@ function providersFailingError(projectName, failures) {
     { projectName, ...failures }
   );
 }
+var RUN_REFUSED_AUDIT_ACTION = "run.refused";
+function recordRunRefusal(db, projectId, failures, audit) {
+  const last = db.select({ diff: auditLog.diff }).from(auditLog).where(and11(eq17(auditLog.projectId, projectId), eq17(auditLog.action, RUN_REFUSED_AUDIT_ACTION))).orderBy(desc7(auditLog.createdAt), desc7(auditLog.id)).limit(1).get();
+  if (last && parseJsonColumn(last.diff, {}).latestRunId === failures.latestRunId) return false;
+  writeAuditLog(db, {
+    projectId,
+    actor: audit.actor,
+    action: RUN_REFUSED_AUDIT_ACTION,
+    entityType: audit.entityType,
+    entityId: audit.entityId,
+    diff: { code: "PROVIDERS_FAILING", ...failures }
+  });
+  return true;
+}
 function queueRunIfProjectIdle(db, params) {
   const createdAt = params.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const kind = params.kind ?? "answer-visibility";
@@ -17553,17 +17677,14 @@ function queueRunIfProjectIdle(db, params) {
     }
     const current = activeRun();
     if (current) return { conflict: true, activeRunId: current.id };
-    const refused = kind === RunKinds["answer-visibility"] ? providerAccountRefusal(tx, {
-      projectId: params.projectId,
-      trigger: stamp?.scope ? RunTriggers.probe : trigger,
-      force: params.force ?? false,
-      now: createdAt,
-      providers: () => providersARunWouldCall(
-        stamp?.identity.providers ?? providerRoster(tx, params),
-        params.runnableProviders
-      )
-    }) : null;
-    if (refused) return { conflict: false, refused };
+    const admission = queueProviderAdmission(tx, params, stamp, createdAt);
+    if (admission.refused) {
+      const refusalRecorded = params.auditRefusal ? recordRunRefusal(tx, params.projectId, admission.refused, params.auditRefusal) : false;
+      return { conflict: false, refused: admission.refused, refusalRecorded };
+    }
+    const skippedProviders = admission.skipped;
+    const admittedDispatch = dispatchAfterProviderAdmission(params, dispatch, admission);
+    const dispatchModes = admittedDispatch.modes;
     const scoped = params.queries != null || stamp?.scope != null;
     const basket = scoped ? null : ensureCurrentQueryBasketRevision(tx, params.projectId, createdAt);
     tx.insert(runs).values({
@@ -17587,10 +17708,11 @@ function queueRunIfProjectIdle(db, params) {
       measurementManifest: stamp?.manifest ?? null,
       measurementScope: stamp?.scope ?? null,
       measurementExecutionIdentity: stamp?.identity ?? null,
-      providerDispatchModes: Object.keys(dispatch.modes).length > 0 ? dispatch.modes : null,
+      providerDispatchModes: Object.keys(dispatchModes).length > 0 ? dispatchModes : null,
+      skippedProviders: Object.keys(skippedProviders).length > 0 ? skippedProviders : null,
       createdAt
     }).run();
-    return { conflict: false, runId, dispatch };
+    return { conflict: false, runId, dispatch: admittedDispatch, skippedProviders };
   });
 }
 
@@ -21005,7 +21127,7 @@ async function runRoutes(app, opts) {
         if (activeRun) {
           return { conflict: true, activeRunId: activeRun.id };
         }
-        const refused = providerAccountRefusal(tx, {
+        const admission = providerAccountAdmission(tx, {
           projectId: project.id,
           trigger,
           force: body.force ?? false,
@@ -21020,7 +21142,8 @@ async function runRoutes(app, opts) {
             return providersARunWouldCall(roster, runnable);
           }
         });
-        if (refused) return { conflict: false, refused };
+        if (admission.refused) return { conflict: false, refused: admission.refused };
+        const skippedProviders = Object.keys(admission.skipped).length > 0 ? admission.skipped : null;
         const inserted = [];
         for (const loc of projectLocations) {
           const runId2 = crypto16.randomUUID();
@@ -21032,6 +21155,7 @@ async function runRoutes(app, opts) {
             trigger,
             location: loc.label,
             queries: queriesColumn,
+            skippedProviders,
             createdAt: now
           }).run();
           inserted.push({ runId: runId2, loc });
@@ -21110,14 +21234,36 @@ async function runRoutes(app, opts) {
     const countRow = app.db.select({ count: sql11`count(*)` }).from(runs).where(and21(eq28(runs.projectId, project.id), notProbeRun())).get();
     const totalRuns = countRow?.count ?? 0;
     const latestRun = app.db.select().from(runs).where(and21(eq28(runs.projectId, project.id), notProbeRun())).orderBy(desc11(runs.createdAt), desc11(runs.id)).limit(1).get();
+    const admissionParams = {
+      projectId: project.id,
+      now: (/* @__PURE__ */ new Date()).toISOString(),
+      runnableProviders: opts.getRunnableProviderNames?.()
+    };
+    const admission = runAdmissionState(app.db, admissionParams);
+    const manualAdmission = runAdmissionState(app.db, { ...admissionParams, selection: RunTriggers.manual });
     if (!latestRun) {
-      return reply.send({ totalRuns: 0, run: null });
+      return reply.send({ totalRuns: 0, run: null, admission, manualAdmission });
     }
     return reply.send({
       totalRuns,
-      run: loadRunDetail(app, latestRun)
+      run: loadRunDetail(app, latestRun),
+      admission,
+      manualAdmission
     });
   });
+  app.get("/projects/:name/run-admission", async (request, reply) => {
+    const selection = request.query.selection ?? RunTriggers.scheduled;
+    if (selection !== RunTriggers.manual && selection !== RunTriggers.scheduled) {
+      throw validationError('"selection" must be one of: manual, scheduled');
+    }
+    const project = resolveProject(app.db, request.params.name);
+    return reply.send(runAdmissionState(app.db, {
+      projectId: project.id,
+      now: (/* @__PURE__ */ new Date()).toISOString(),
+      runnableProviders: opts.getRunnableProviderNames?.(),
+      selection
+    }));
+  });
   app.get("/runs", async (request, reply) => {
     const limit = parseListLimit(request.query.limit, 500, 5e3);
     const since = parseListSince(request.query.since);
@@ -21210,6 +21356,7 @@ async function runRoutes(app, opts) {
     for (const entry of eligible) {
       try {
         assertMeasurementRunStampable(app.db, {
+          createdAt: now,
           projectId: entry.project.id,
           kind,
           trigger: "manual",
@@ -21218,7 +21365,8 @@ async function runRoutes(app, opts) {
           runnableProviders: runnableProviderNames,
           providerModels: opts.getEffectiveProviderModels?.(),
           dispatchMode,
-          batchEligibleProviders
+          batchEligibleProviders,
+          force: force ?? false
         });
         dispatchable.push(entry);
       } catch (error) {
@@ -21434,6 +21582,8 @@ function formatRun(row) {
       // Only plan runs can batch, so only they carry the frozen modes.
       dispatchModes: row.providerDispatchModes ?? {}
     } : {},
+    // Only on a run that skipped a provider, so other runs read as before.
+    ...row.skippedProviders && Object.keys(row.skippedProviders).length > 0 ? { skippedProviders: row.skippedProviders } : {},
     createdAt: row.createdAt
   };
 }
@@ -34087,6 +34237,128 @@ function clickPeriods(periods, clicks, impressions) {
     impressions: impressions[index2] ?? 0
   }));
 }
+function compareCodeUnits(left, right) {
+  if (left < right) return -1;
+  return left > right ? 1 : 0;
+}
+function aiEngineLeadPeriods(periods, eventCounts, sessionCounts, leadRateAvailable) {
+  return periods.map((period2, index2) => {
+    const eventCount = eventCounts[index2] ?? 0;
+    const sessions = sessionCounts[index2] ?? 0;
+    return {
+      ...period2,
+      eventCount,
+      sessions,
+      leadRate: leadRateAvailable && sessions > 0 ? roundRatio(eventCount / sessions, RatioUnits.fraction) : null
+    };
+  });
+}
+var UNATTRIBUTED_AI = "(unattributed)";
+function buildAiEngineLeadClass(input) {
+  const { periods, leadRateAvailable } = input;
+  const sourcesByKey = /* @__PURE__ */ new Map();
+  for (const row of [...input.leads, ...input.sessions]) {
+    const sources = sourcesByKey.get(row.key) ?? /* @__PURE__ */ new Set();
+    sources.add(row.source);
+    sourcesByKey.set(row.key, sources);
+  }
+  const leadsByKey = aggregateByKey(input.leads, periods, (row) => row.key, (row) => row.value);
+  const sessionsByKey = aggregateByKey(input.sessions, periods, (row) => row.key, (row) => row.value);
+  const zeros = Array(periods.length).fill(0);
+  const sum = (values) => values.reduce((total, value) => total + value, 0);
+  const countsFor = (key) => ({
+    leads: leadsByKey.get(key) ?? zeros,
+    sessions: sessionsByKey.get(key) ?? zeros
+  });
+  const sourcesFor = (key) => [...sourcesByKey.get(key) ?? []].sort(compareCodeUnits);
+  const engineRows = [...sourcesByKey.keys()].filter((key) => key !== UNATTRIBUTED_AI).map((engine) => ({ engine, ...countsFor(engine) })).sort((left, right) => (right.leads.at(-1) ?? 0) - (left.leads.at(-1) ?? 0) || sum(right.leads) - sum(left.leads) || (right.sessions.at(-1) ?? 0) - (left.sessions.at(-1) ?? 0) || sum(right.sessions) - sum(left.sessions) || left.engine.localeCompare(right.engine));
+  const unattributed = countsFor(UNATTRIBUTED_AI);
+  const allRows = [...engineRows, unattributed];
+  const totalLeads = periods.map((_, index2) => sum(allRows.map((row) => row.leads[index2] ?? 0)));
+  const totalSessions = periods.map((_, index2) => sum(allRows.map((row) => row.sessions[index2] ?? 0)));
+  return {
+    periods: aiEngineLeadPeriods(periods, totalLeads, totalSessions, leadRateAvailable),
+    engines: engineRows.map((row) => ({
+      engine: row.engine,
+      label: aiReferralEngineLabel(row.engine),
+      sources: sourcesFor(row.engine),
+      periods: aiEngineLeadPeriods(periods, row.leads, row.sessions, leadRateAvailable)
+    })),
+    unattributed: {
+      sources: sourcesFor(UNATTRIBUTED_AI),
+      periods: aiEngineLeadPeriods(periods, unattributed.leads, unattributed.sessions, leadRateAvailable)
+    }
+  };
+}
+function attributeAiEngineRows(input) {
+  const engineBySource = /* @__PURE__ */ new Map();
+  const engineOf = (source) => {
+    let engine = engineBySource.get(source);
+    if (engine === void 0) {
+      engine = aiEngineForReferralSource(source);
+      engineBySource.set(source, engine);
+    }
+    return engine;
+  };
+  let paidOnlyByLandingPage = false;
+  const attribute = (rows, valueOf) => rows.flatMap((row) => {
+    const engine = engineOf(row.source);
+    if (engine === null && !isGa4AiAssistantChannel(row.channelGroup)) return [];
+    const evidence = { source: row.source, medium: row.medium, channelGroup: row.channelGroup };
+    const withLandingPage = classifyAiReferralTrafficClass({ ...evidence, landingPage: row.landingPage });
+    const trafficClass = input.landingPageEvidence ? withLandingPage : classifyAiReferralTrafficClass({ ...evidence, landingPage: null });
+    if (trafficClass !== withLandingPage) paidOnlyByLandingPage = true;
+    return [{
+      date: row.date,
+      source: row.source,
+      key: engine ?? UNATTRIBUTED_AI,
+      trafficClass,
+      value: valueOf(row)
+    }];
+  });
+  const leads = attribute(input.leads, (row) => row.eventCount);
+  const sessions = attribute(input.sessions, (row) => row.sessions);
+  return { leads, sessions, paidOnlyByLandingPage };
+}
+function buildAiEngineLeads(input) {
+  const leadRateAvailable = input.leadRateUnavailableReason === null;
+  const classBlock = (trafficClass) => buildAiEngineLeadClass({
+    periods: input.periods,
+    leads: input.leads.filter((row) => row.trafficClass === trafficClass),
+    sessions: input.sessions.filter((row) => row.trafficClass === trafficClass),
+    leadRateAvailable
+  });
+  return {
+    leadRateAvailable,
+    leadRateUnavailableReason: input.leadRateUnavailableReason,
+    organic: classBlock(AiReferralTrafficClasses.organic),
+    paid: classBlock(AiReferralTrafficClasses.paid)
+  };
+}
+function latestDate(rows) {
+  let latest = null;
+  for (const row of rows) {
+    if (latest === null || row.date > latest) latest = row.date;
+  }
+  return latest;
+}
+function hasLeadDayWithoutSessions(acquisitionRows, leadRows) {
+  const acquisitionDates = new Set(acquisitionRows.map((row) => row.date));
+  return leadRows.some((row) => !acquisitionDates.has(row.date));
+}
+function aiEngineLeadRateUnavailableReason(input) {
+  if (!input.hasData) return AiEngineLeadRateUnavailableReasons["no-data"];
+  if (input.acquisitionStatus !== "ready" || input.leadStatus !== "ready") {
+    return AiEngineLeadRateUnavailableReasons["sync-not-ready"];
+  }
+  if (input.channelLeadsUnfiltered) return AiEngineLeadRateUnavailableReasons["channel-leads-unfiltered"];
+  if (input.paidOnlyByLandingPage) return AiEngineLeadRateUnavailableReasons["paid-split-needs-landing-page"];
+  if (input.latestLeadDate !== null && (input.latestAcquisitionDate === null || input.latestAcquisitionDate < input.latestLeadDate)) {
+    return AiEngineLeadRateUnavailableReasons["sessions-behind-leads"];
+  }
+  if (input.leadDayWithoutSessions) return AiEngineLeadRateUnavailableReasons["sessions-missing-on-lead-days"];
+  return null;
+}
 function engagementPeriods(periods, rows) {
   return periods.map((period2) => {
     const inPeriod = rows.filter((row) => row.date >= period2.startDate && row.date <= period2.endDate);
@@ -34303,6 +34575,28 @@ function buildGaMeasurementAnalysis(db, projectName, options = {}) {
     (row) => row.channelGroup,
     (row) => row.eventCount
   );
+  const filtersNarrowSessions = parsedHostScope.data === "marketing" || pathPrefix !== null && pathPrefix !== "/";
+  const hasAiEngineLeadData = gaAnchor !== null && hasLeadTimeline;
+  const aiEngineRows = attributeAiEngineRows({
+    leads: hasAiEngineLeadData ? leads : [],
+    sessions: hasAiEngineLeadData ? acquisition : [],
+    landingPageEvidence: attributionScope !== "channel"
+  });
+  const aiEngineLeads = buildAiEngineLeads({
+    periods: hasAiEngineLeadData ? gaPeriods : [],
+    leads: aiEngineRows.leads,
+    sessions: aiEngineRows.sessions,
+    leadRateUnavailableReason: aiEngineLeadRateUnavailableReason({
+      hasData: hasAiEngineLeadData,
+      acquisitionStatus: state?.acquisitionStatus,
+      leadStatus: state?.leadStatus,
+      channelLeadsUnfiltered: attributionScope === "channel" && filtersNarrowSessions,
+      paidOnlyByLandingPage: aiEngineRows.paidOnlyByLandingPage,
+      latestAcquisitionDate: latestDate(acquisitionRows),
+      latestLeadDate: latestDate(leadRows),
+      leadDayWithoutSessions: hasLeadDayWithoutSessions(acquisitionRows, leadRows)
+    })
+  });
   const propertyClicks = aggregateByKey(
     propertyRows,
     gscPeriods,
@@ -34407,7 +34701,8 @@ function buildGaMeasurementAnalysis(db, projectName, options = {}) {
       channels: rankEntries(leadChannels).map(([channelGroup, values]) => ({
         channelGroup,
         periods: eventPeriods(gaPeriods, values)
-      }))
+      })),
+      aiEngines: aiEngineLeads
     },
     engagement: {
       status: engagementAnchor === null ? "unavailable" : "ready",
@@ -36404,7 +36699,14 @@ async function compositeRoutes(app, options) {
     const previousVisRunGroup = visRunGroups[1] ?? [];
     const previousVisibilityRun = pickGroupRepresentative(previousVisRunGroup);
     const latestRunRow = allRuns[0] ?? null;
-    const latestRun = latestRunRow ? { totalRuns, run: summarizeRun(latestRunRow) } : { totalRuns: 0, run: null };
+    const admissionParams = {
+      projectId: project.id,
+      now: (/* @__PURE__ */ new Date()).toISOString(),
+      runnableProviders: options.getRunnableProviderNames?.()
+    };
+    const admission = runAdmissionState(app.db, admissionParams);
+    const manualAdmission = runAdmissionState(app.db, { ...admissionParams, selection: RunTriggers.manual });
+    const latestRun = latestRunRow ? { totalRuns, run: summarizeRun(latestRunRow), admission, manualAdmission } : { totalRuns: 0, run: null, admission, manualAdmission };
     const healthRow = app.db.select().from(healthSnapshots).where(eq50(healthSnapshots.projectId, project.id)).orderBy(desc24(healthSnapshots.createdAt)).limit(1).get();
     const health = healthRow ? mapHealthRow2(healthRow) : null;
     const insightRows = app.db.select().from(insights).where(eq50(insights.projectId, project.id)).orderBy(desc24(insights.createdAt)).all();
@@ -36644,6 +36946,7 @@ function summarizeRun(run) {
     startedAt: run.startedAt,
     finishedAt: run.finishedAt,
     error: parseRunError(run.error),
+    ...run.skippedProviders && Object.keys(run.skippedProviders).length > 0 ? { skippedProviders: run.skippedProviders } : {},
     createdAt: run.createdAt
   };
 }
@@ -38068,6 +38371,7 @@ var SCHEMA_TABLE = {
   IntegrationSettingsSummaryDto: integrationSettingsSummaryDtoSchema,
   KeywordDto: keywordDtoSchema,
   LatestProjectRunDto: latestProjectRunDtoSchema,
+  RunAdmissionDto: runAdmissionDtoSchema,
   LocationContext: locationContextSchema,
   MeasurementDiscoveryRequest: measurementDiscoveryRequestSchema,
   MeasurementDiscoveryResponse: measurementDiscoveryResponseSchema,
@@ -40544,7 +40848,7 @@ var routeCatalog = [
               dispatchMode: dispatchModeRequestSchema,
               force: {
                 type: "boolean",
-                description: "Queue the run even when it would be refused with PROVIDERS_FAILING. Admission only; never stored."
+                description: "Call every provider: queue the run even when it would be refused with PROVIDERS_FAILING, and skip no provider that keeps failing on its account. Admission only; never stored."
               }
             }
           }
@@ -40552,12 +40856,15 @@ var routeCatalog = [
       }
     },
     responses: {
-      201: jsonResponse("Run queued.", "RunDto"),
+      201: jsonResponse(
+        `Run queued. \`skippedProviders\` names each provider it will not call because that provider failed on its account in each of its last ${PROVIDER_ACCOUNT_FAILURE_STREAK} runs (until its \`retryAfter\`); the run calls the rest and ends partial.`,
+        "RunDto"
+      ),
       400: errorResponse(
         'Invalid request: an untracked query, a measurement scope naming a group/target/question the published plan does not contain, a scope combined with a query list, a per-run location on a plan project, a provider roster the plan was not published for, or `dispatchMode: "batch"` when no provider of the run can batch (`details.ineligible` names each provider\'s reason).'
       ),
       422: errorResponse(
-        `NO_QUERIES: the project has no tracked queries. PROVIDERS_FAILING: every provider the run would call failed on its account (rejected key, denied access, no credit) in each of its last ${PROVIDER_ACCOUNT_FAILURE_STREAK} runs. \`details.providers\` names each provider's code and \`details.retryAfter\` when one run is let through again (${PROVIDER_ACCOUNT_RETRY_HOURS}h after the newest failure). Saving a new key, model or endpoint in a provider's settings lets the next run through at once, a probe is never refused, and \`force: true\` overrides.`
+        `NO_QUERIES: the project has no tracked queries. PROVIDERS_FAILING: every provider the run would call failed on its account (rejected key, denied access, no credit) in each of its last ${PROVIDER_ACCOUNT_FAILURE_STREAK} runs. \`details.providers\` names each provider's code and \`details.retryAfter\` when one run is let through again (${PROVIDER_ACCOUNT_RETRY_HOURS}h after a provider's newest failure; the run then calls only the providers due a retry). Saving a new key, model or endpoint in a provider's settings lets the next run through at once, a probe is never refused, and \`force: true\` overrides. When only some providers keep failing, the run is queued without them instead.`
       ),
       409: errorResponse("Run already in progress."),
       503: errorResponse("No runnable answer provider is configured.")
@@ -40577,12 +40884,33 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/runs/latest",
     summary: "Get the latest project run",
+    description: "The newest non-probe run, the run count, and `admission`: whether the next full sweep would be refused (PROVIDERS_FAILING) and which providers it would skip because each keeps failing on its account, with their codes and `retryAfter`. `admission` uses the scheduled roster; `manualAdmission` describes an unfiltered manual launch. A scheduled sweep that is refused leaves no run, so read `admission`, not the latest run, to tell.",
     tags: ["runs"],
     parameters: [nameParameter],
     responses: {
       200: jsonResponse("Latest run returned.", "LatestProjectRunDto")
     }
   },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/run-admission",
+    summary: "Get whether the next sweep would be admitted",
+    description: `The \`admission\` or \`manualAdmission\` of \`/projects/{name}/runs/latest\` without the latest run: whether the next full sweep would be refused (PROVIDERS_FAILING) and which providers it would skip because each failed on its account in each of its last ${PROVIDER_ACCOUNT_FAILURE_STREAK} runs, with each provider's code and \`retryAfter\`.`,
+    tags: ["runs"],
+    parameters: [
+      nameParameter,
+      {
+        name: "selection",
+        in: "query",
+        description: "Read-selection identity: scheduled (default) uses the enabled schedule's providers; manual uses the unfiltered manual launch's project or instance providers. Both use an Advanced revision's frozen engines.",
+        schema: { type: "string", enum: ["manual", "scheduled"], default: "scheduled" }
+      }
+    ],
+    responses: {
+      200: jsonResponse("Run admission returned.", "RunAdmissionDto"),
+      400: errorResponse("Invalid admission selection.")
+    }
+  },
   {
     method: "get",
     path: "/api/v1/runs",
@@ -40617,7 +40945,7 @@ var routeCatalog = [
               dispatchMode: dispatchModeRequestSchema,
               force: {
                 type: "boolean",
-                description: "Queue projects that would be refused with PROVIDERS_FAILING. Admission only; never stored."
+                description: "Call every provider: queue projects that would be refused with PROVIDERS_FAILING, and skip no provider that keeps failing on its account. Admission only; never stored."
               }
             }
           }
@@ -76149,7 +76477,6 @@ function verifyIpForRuleDecision(ip, ruleId) {
 }
 
 // ../integration-traffic/src/rules.ts
-var LEGACY_CHATGPT_DOMAIN = "chat.openai.com";
 var SELF_TRAFFIC_USER_AGENT_PATTERNS = [
   /AINYC-AEO-Audit\//i
 ];
@@ -76532,7 +76859,7 @@ var DEFAULT_AI_CRAWLER_USER_AGENT_SUBSTRINGS = [
 ];
 var DEFAULT_AI_REFERRER_RULES = [
   { domain: AI_ENGINE_DOMAINS.chatgpt, operator: "OpenAI", product: "ChatGPT" },
-  { domain: LEGACY_CHATGPT_DOMAIN, operator: "OpenAI", product: "ChatGPT" },
+  { domain: AI_ENGINE_DOMAINS.chatgptLegacy, operator: "OpenAI", product: "ChatGPT" },
   { domain: AI_ENGINE_DOMAINS.perplexity, operator: "Perplexity", product: "Perplexity" },
   { domain: AI_ENGINE_DOMAINS.claude, operator: "Anthropic", product: "Claude" },
   { domain: AI_ENGINE_DOMAINS.gemini, operator: "Google", product: "Gemini" },
@@ -89646,7 +89973,7 @@ async function apiRoutes(app, opts) {
     await api.register(citationRoutes);
     await api.register(visibilityStatsRoutes);
     await api.register(resultsExportRoutes);
-    await api.register(compositeRoutes, { sentiment: opts.sentiment });
+    await api.register(compositeRoutes, { sentiment: opts.sentiment, getRunnableProviderNames: opts.getRunnableProviderNames });
     await api.register(contentRoutes, {
       explainContentRecommendation: opts.explainContentRecommendation,
       briefContentRecommendation: opts.briefContentRecommendation,