@canonry/canonry 7.83.2 → 7.85.0

package/dist/{chunk-OMNS42ZQ.js → chunk-2X6UAPAC.js}

@@ -1,9 +1,47 @@
 import {
-  parseJsonColumn
-} from "./chunk-3UFQI4KL.js";
+  createLogger
+} from "./chunk-6SGHSSWQ.js";
+import {
+  addLikelyFakeAgentHits,
+  correctBackgroundCallJourneys,
+  mergeSplitJourneyVisitors,
+  writeUnrecognizedAgentBuckets
+} from "./chunk-JVO5GQZH.js";
+import {
+  AGENT_TRUST_RULES_VERSION,
+  BROWSER_SHAPED_AGENT_MARKERS,
+  DEFAULT_AI_CRAWLER_RULES,
+  GENERIC_HTTP_CLIENTS,
+  JOURNEY_RULES_VERSION,
+  SCANNER_BURST_WINDOW_MS,
+  SELF_TRAFFIC_USER_AGENT_PATTERNS,
+  UNLISTED_AGENT_SKIPPED_EXTENSIONS,
+  UNRECOGNIZED_AGENT_NAMING_VERSION,
+  classifyAiUserFetch,
+  classifyCrawler,
+  isScannerPath,
+  isSelfTraffic,
+  normalizeTrafficPathPattern,
+  unrecognizedAgentName
+} from "./chunk-2R6WI237.js";
+import {
+  RawEventSampleEventTypes,
+  agentJourneyCaptureDays,
+  agentJourneyEvents,
+  aiUserFetchEventsHourly,
+  aiUserFetchVerificationManifestsHourly,
+  crawlerEventsHourly,
+  migrationsTable,
+  parseJsonColumn,
+  rawEventSamples,
+  trafficReclassificationState,
+  unrecognizedAgentEventsHourly
+} from "./chunk-L5R5S57T.js";
 import {
   AI_ENGINE_DOMAINS,
   AI_ENGINE_SELF_DOMAINS,
+  AgentTrustLevels,
+  AgentTrustReasons,
   AnchoredSpanSources,
   OPENROUTER_MODEL_PATTERN,
   OPENROUTER_ROUTE_FAMILY,
@@ -12,7 +50,12 @@ import {
   ProviderNames,
   RetrievalContracts,
   RetrievalStatuses,
+  TrafficEventConfidences,
+  TrafficEvidenceKinds,
+  TrafficSourceTypes,
+  UNRECORDED_TRAFFIC_PATH,
   VERTEX_AI_SEARCH_PROXY_DOMAIN,
+  VerificationStatuses,
   asRecord,
   describeError,
   hostMatchesAnyDomain,
@@ -26,7 +69,7 @@ import {
   retryAfterDelayMs,
   usageCount,
   withRetry
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-KNKOTLVW.js";
 
 // ../provider-openai/src/normalize.ts
 import OpenAI from "openai";
@@ -2895,6 +2938,480 @@ function extractStoredAnswerAnchors(provider, rawResponse) {
   }
 }
 
+// src/traffic-reclassify.ts
+import { createHash } from "crypto";
+import { setImmediate as yieldToEventLoop } from "timers/promises";
+import { and, eq, gte, inArray, lte, ne, sql } from "drizzle-orm";
+var log = createLogger("TrafficReclassify");
+var STATE_ID = "default";
+var BATCH_SIZE = 200;
+var UNRECOGNIZED_TABLE_MIGRATION = 201;
+var TRAFFIC_RECLASSIFY_START_DELAY_MS = 3e4;
+function trafficClassificationFingerprint() {
+  const pattern = (value) => `/${value.source}/${value.flags}`;
+  return createHash("sha256").update(JSON.stringify({
+    rules: DEFAULT_AI_CRAWLER_RULES.map((rule) => ({
+      id: rule.id,
+      operator: rule.operator,
+      product: rule.product,
+      purpose: rule.purpose,
+      patterns: rule.userAgentPatterns.map(pattern)
+    })),
+    self: SELF_TRAFFIC_USER_AGENT_PATTERNS.map(pattern),
+    naming: UNRECOGNIZED_AGENT_NAMING_VERSION,
+    trust: AGENT_TRUST_RULES_VERSION,
+    journeys: JOURNEY_RULES_VERSION,
+    genericClients: GENERIC_HTTP_CLIENTS,
+    browserMarkers: BROWSER_SHAPED_AGENT_MARKERS,
+    skippedExtensions: UNLISTED_AGENT_SKIPPED_EXTENSIONS
+  })).digest("hex");
+}
+function probeRequest(userAgent, path, observedAt) {
+  return {
+    sourceType: TrafficSourceTypes["cloud-run"],
+    evidenceKind: TrafficEvidenceKinds["raw-request"],
+    confidence: TrafficEventConfidences.observed,
+    eventId: "reclassify",
+    observedAt,
+    method: "GET",
+    requestUrl: `https://placeholder${path.startsWith("/") ? path : "/"}`,
+    host: "placeholder",
+    path,
+    queryString: null,
+    status: 200,
+    userAgent,
+    // Stored traffic keeps no client address, so no replay can verify an IP.
+    remoteIp: null,
+    referer: null,
+    latencyMs: null,
+    requestSizeBytes: null,
+    responseSizeBytes: null,
+    providerResource: { type: "cloud_run_revision", labels: {} },
+    providerLabels: {}
+  };
+}
+function classifyStored(userAgent, path, observedAt) {
+  const request2 = probeRequest(userAgent, path, observedAt);
+  if (isSelfTraffic(request2)) return { kind: "self" };
+  const fetch2 = classifyAiUserFetch(request2);
+  if (fetch2) return { kind: "user-fetch", fetch: fetch2 };
+  const crawler = classifyCrawler(request2);
+  if (crawler) return { kind: "crawler", crawler };
+  return { kind: "unknown" };
+}
+function sqliteUtcToIso(value) {
+  return /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(value) ? `${value.replace(" ", "T")}Z` : value;
+}
+function hourOf(iso) {
+  const hour = new Date(iso);
+  hour.setUTCMinutes(0, 0, 0);
+  return hour.toISOString();
+}
+function unrecognizedCountingStart(db) {
+  const row = db.select({ appliedAt: migrationsTable.appliedAt }).from(migrationsTable).where(eq(migrationsTable.version, UNRECOGNIZED_TABLE_MIGRATION)).get();
+  return row ? hourOf(sqliteUtcToIso(row.appliedAt)) : null;
+}
+function addHourlyHits(tx, opts) {
+  const { projectId, sourceId, tsHour, verdict, pathNormalized, status, hits, sampledUserAgent, now } = opts;
+  if (verdict.kind === "user-fetch" && verdict.fetch.trust === AgentTrustLevels.likely_fake) {
+    addLikelyFakeAgentHits(tx, {
+      projectId,
+      sourceId,
+      buckets: [{ tsHour, botId: verdict.fetch.botId, operator: verdict.fetch.operator, reason: verdict.fetch.trustReasons[0], hits }],
+      now
+    });
+    return;
+  }
+  const table = verdict.kind === "user-fetch" ? aiUserFetchEventsHourly : crawlerEventsHourly;
+  const classified = verdict.kind === "user-fetch" ? verdict.fetch : verdict.crawler;
+  tx.insert(table).values({
+    projectId,
+    sourceId,
+    tsHour,
+    botId: classified.botId,
+    operator: classified.operator,
+    verificationStatus: classified.verificationStatus,
+    pathNormalized,
+    status,
+    hits,
+    sampledUserAgent,
+    createdAt: now,
+    updatedAt: now
+  }).onConflictDoUpdate({
+    target: [table.projectId, table.sourceId, table.tsHour, table.botId, table.verificationStatus, table.pathNormalized, table.status],
+    set: { hits: sql`${table.hits} + ${hits}`, updatedAt: now }
+  }).run();
+}
+function botIdOf(verdict) {
+  return verdict.kind === "user-fetch" ? verdict.fetch.botId : verdict.crawler.botId;
+}
+async function reclassifyUnrecognizedRows(db, opts) {
+  const result = { examined: 0, moved: 0, movedHits: 0, renamed: 0, removed: 0, byBot: {} };
+  const table = unrecognizedAgentEventsHourly;
+  const verdicts = /* @__PURE__ */ new Map();
+  const lastStartingRowid = Number(db.select({ max: sql`max(rowid)` }).from(table).get()?.max ?? 0);
+  let lastRowid = 0;
+  for (; ; ) {
+    if (opts.shouldStop()) break;
+    const keys = db.select({ rowid: sql`rowid`, projectId: table.projectId, sourceId: table.sourceId, tsHour: table.tsHour, agentName: table.agentName }).from(table).where(and(
+      sql`rowid > ${lastRowid}`,
+      sql`rowid <= ${lastStartingRowid}`,
+      opts.projectIds ? inArray(table.projectId, [...opts.projectIds]) : void 0
+    )).orderBy(sql`rowid`).limit(BATCH_SIZE).all();
+    if (keys.length === 0) break;
+    lastRowid = keys[keys.length - 1].rowid;
+    result.examined += keys.length;
+    db.transaction((tx) => {
+      for (const key of keys) {
+        const match = and(
+          eq(table.projectId, key.projectId),
+          eq(table.sourceId, key.sourceId),
+          eq(table.tsHour, key.tsHour),
+          eq(table.agentName, key.agentName)
+        );
+        const row = tx.select().from(table).where(match).get();
+        if (!row?.sampledUserAgent) continue;
+        const userAgent = row.sampledUserAgent;
+        let verdict = verdicts.get(userAgent);
+        if (!verdict) {
+          verdict = classifyStored(userAgent, "/", row.tsHour);
+          verdicts.set(userAgent, verdict);
+        }
+        if (verdict.kind === "self") {
+          result.removed++;
+          if (!opts.dryRun) tx.delete(table).where(match).run();
+          continue;
+        }
+        if (verdict.kind === "user-fetch" || verdict.kind === "crawler") {
+          result.moved++;
+          result.movedHits += row.hits;
+          const botId = botIdOf(verdict);
+          result.byBot[botId] = (result.byBot[botId] ?? 0) + row.hits;
+          if (opts.dryRun) continue;
+          addHourlyHits(tx, {
+            projectId: row.projectId,
+            sourceId: row.sourceId,
+            tsHour: row.tsHour,
+            verdict,
+            pathNormalized: UNRECORDED_TRAFFIC_PATH,
+            status: 0,
+            hits: row.hits,
+            sampledUserAgent: userAgent,
+            now: opts.now
+          });
+          tx.delete(table).where(match).run();
+          continue;
+        }
+        const name = unrecognizedAgentName({ method: "GET", path: row.sampledPath, userAgent });
+        if (name === row.agentName) continue;
+        if (name === null) {
+          result.removed++;
+          if (!opts.dryRun) tx.delete(table).where(match).run();
+          continue;
+        }
+        result.renamed++;
+        if (opts.dryRun) continue;
+        tx.delete(table).where(match).run();
+        writeUnrecognizedAgentBuckets(tx, {
+          projectId: row.projectId,
+          sourceId: row.sourceId,
+          buckets: [{ tsHour: row.tsHour, agentName: name, hits: row.hits, sampledUserAgent: userAgent, sampledPath: row.sampledPath ?? "" }],
+          now: opts.now
+        });
+      }
+    }, { behavior: "immediate" });
+    await yieldToEventLoop();
+  }
+  return result;
+}
+async function reclassifyUnknownSamples(db, opts) {
+  const result = { examined: 0, reclassified: 0, counted: 0, removed: 0, byBot: {} };
+  const countingStart = unrecognizedCountingStart(db);
+  const lastStartingRowid = Number(db.select({ max: sql`max(rowid)` }).from(rawEventSamples).get()?.max ?? 0);
+  let lastRowid = 0;
+  for (; ; ) {
+    if (opts.shouldStop()) break;
+    const samples = db.select({
+      rowid: sql`rowid`,
+      id: rawEventSamples.id,
+      projectId: rawEventSamples.projectId,
+      sourceId: rawEventSamples.sourceId,
+      ts: rawEventSamples.ts,
+      userAgent: rawEventSamples.userAgent,
+      pathNormalized: rawEventSamples.pathNormalized,
+      status: rawEventSamples.status
+    }).from(rawEventSamples).where(and(
+      eq(rawEventSamples.eventType, RawEventSampleEventTypes.unknown),
+      sql`rowid > ${lastRowid}`,
+      sql`rowid <= ${lastStartingRowid}`,
+      opts.projectIds ? inArray(rawEventSamples.projectId, [...opts.projectIds]) : void 0
+    )).orderBy(sql`rowid`).limit(BATCH_SIZE).all();
+    if (samples.length === 0) break;
+    lastRowid = samples[samples.length - 1].rowid;
+    result.examined += samples.length;
+    db.transaction((tx) => {
+      for (const sample of samples) {
+        if (!sample.userAgent) continue;
+        const verdict = classifyStored(sample.userAgent, sample.pathNormalized, sample.ts);
+        if (verdict.kind === "self") {
+          result.removed++;
+          if (!opts.dryRun) tx.delete(rawEventSamples).where(eq(rawEventSamples.id, sample.id)).run();
+          continue;
+        }
+        if (verdict.kind === "unknown") continue;
+        result.reclassified++;
+        const botId = botIdOf(verdict);
+        result.byBot[botId] = (result.byBot[botId] ?? 0) + 1;
+        const tsHour = hourOf(sample.ts);
+        const countSample = countingStart === null || tsHour < countingStart || unrecognizedAgentName({ method: "GET", path: sample.pathNormalized, userAgent: sample.userAgent }) === null;
+        if (countSample) result.counted++;
+        if (opts.dryRun) continue;
+        tx.update(rawEventSamples).set({
+          eventType: verdict.kind === "user-fetch" ? RawEventSampleEventTypes.aiUserFetch : RawEventSampleEventTypes.crawler,
+          classifierDetailsJson: {
+            crawler: verdict.kind === "crawler" ? { ...verdict.crawler, verificationManifest: null } : null,
+            aiUserFetch: verdict.kind === "user-fetch" ? { ...verdict.fetch, verificationManifest: null } : null,
+            aiReferral: null
+          }
+        }).where(eq(rawEventSamples.id, sample.id)).run();
+        if (!countSample) continue;
+        addHourlyHits(tx, {
+          projectId: sample.projectId,
+          sourceId: sample.sourceId,
+          tsHour,
+          verdict,
+          pathNormalized: sample.pathNormalized,
+          status: sample.status ?? 200,
+          hits: 1,
+          sampledUserAgent: sample.userAgent,
+          now: opts.now
+        });
+      }
+    }, { behavior: "immediate" });
+    await yieldToEventLoop();
+  }
+  return result;
+}
+function hourlyAgentRow(key) {
+  const table = aiUserFetchEventsHourly;
+  return and(
+    eq(table.projectId, key.projectId),
+    eq(table.sourceId, key.sourceId),
+    eq(table.tsHour, key.tsHour),
+    eq(table.botId, key.botId),
+    eq(table.verificationStatus, key.verificationStatus),
+    eq(table.pathNormalized, key.pathNormalized),
+    eq(table.status, key.status)
+  );
+}
+async function reassessAgentHits(db, opts) {
+  const result = { examined: 0, moved: 0, movedHits: 0 };
+  const table = aiUserFetchEventsHourly;
+  const lastStartingRowid = Number(db.select({ max: sql`max(rowid)` }).from(table).get()?.max ?? 0);
+  let lastRowid = 0;
+  for (; ; ) {
+    if (opts.shouldStop()) break;
+    const rows = db.select({
+      rowid: sql`rowid`,
+      projectId: table.projectId,
+      sourceId: table.sourceId,
+      tsHour: table.tsHour,
+      botId: table.botId,
+      operator: table.operator,
+      verificationStatus: table.verificationStatus,
+      pathNormalized: table.pathNormalized,
+      status: table.status
+    }).from(table).where(and(
+      sql`rowid > ${lastRowid}`,
+      sql`rowid <= ${lastStartingRowid}`,
+      ne(table.verificationStatus, VerificationStatuses.verified),
+      opts.projectIds ? inArray(table.projectId, [...opts.projectIds]) : void 0
+    )).orderBy(sql`rowid`).limit(BATCH_SIZE).all();
+    if (rows.length === 0) break;
+    lastRowid = rows[rows.length - 1].rowid;
+    result.examined += rows.length;
+    const probes = rows.filter((row) => isScannerPath(row.pathNormalized));
+    if (probes.length > 0) {
+      db.transaction((tx) => {
+        for (const row of probes) {
+          const current = tx.select({ hits: table.hits }).from(table).where(hourlyAgentRow(row)).get();
+          if (!current) continue;
+          result.moved++;
+          result.movedHits += current.hits;
+          if (opts.dryRun) continue;
+          addLikelyFakeAgentHits(tx, {
+            projectId: row.projectId,
+            sourceId: row.sourceId,
+            buckets: [{ tsHour: row.tsHour, botId: row.botId, operator: row.operator, reason: AgentTrustReasons["scanner-path"], hits: current.hits }],
+            now: opts.now
+          });
+          tx.delete(table).where(hourlyAgentRow(row)).run();
+        }
+      }, { behavior: "immediate" });
+    }
+    await yieldToEventLoop();
+  }
+  return result;
+}
+function moveAgentHitToBurst(tx, row, now) {
+  const key = {
+    projectId: row.projectId,
+    sourceId: row.sourceId,
+    tsHour: hourOf(row.ts),
+    botId: row.agentId,
+    verificationStatus: row.verificationStatus,
+    pathNormalized: normalizeTrafficPathPattern(row.path),
+    status: row.status ?? 0
+  };
+  const table = aiUserFetchEventsHourly;
+  const taken = tx.update(table).set({ hits: sql`${table.hits} - 1`, updatedAt: now }).where(and(hourlyAgentRow(key), sql`${table.hits} > 0`)).run();
+  if (taken.changes === 0) return;
+  const manifests = aiUserFetchVerificationManifestsHourly;
+  if (row.verificationManifest) {
+    const manifestRow = and(
+      eq(manifests.projectId, key.projectId),
+      eq(manifests.sourceId, key.sourceId),
+      eq(manifests.tsHour, key.tsHour),
+      eq(manifests.botId, key.botId),
+      eq(manifests.verificationStatus, key.verificationStatus),
+      eq(manifests.pathNormalized, key.pathNormalized),
+      eq(manifests.status, key.status),
+      eq(manifests.manifestId, row.verificationManifest.id)
+    );
+    tx.update(manifests).set({ hits: sql`${manifests.hits} - 1`, updatedAt: now }).where(and(manifestRow, sql`${manifests.hits} > 0`)).run();
+    tx.delete(manifests).where(and(manifestRow, sql`${manifests.hits} <= 0`)).run();
+  }
+  tx.delete(table).where(and(hourlyAgentRow(key), sql`${table.hits} <= 0`)).run();
+  addLikelyFakeAgentHits(tx, {
+    projectId: row.projectId,
+    sourceId: row.sourceId,
+    buckets: [{ tsHour: key.tsHour, botId: row.agentId, operator: row.operator, reason: AgentTrustReasons["scanner-burst"], hits: 1 }],
+    now
+  });
+}
+async function reassessAgentRequests(db, opts) {
+  const result = { examined: 0, probes: 0, removed: 0 };
+  const table = agentJourneyEvents;
+  const clients = /* @__PURE__ */ new Map();
+  const lastStartingRowid = Number(db.select({ max: sql`max(rowid)` }).from(table).get()?.max ?? 0);
+  let lastRowid = 0;
+  for (; ; ) {
+    if (opts.shouldStop()) return result;
+    const rows = db.select({ rowid: sql`rowid`, projectId: table.projectId, sourceId: table.sourceId, correlationKey: table.correlationKey, ts: table.ts, path: table.path }).from(table).where(and(
+      sql`rowid > ${lastRowid}`,
+      sql`rowid <= ${lastStartingRowid}`,
+      ne(table.trust, AgentTrustLevels.verified),
+      opts.projectIds ? inArray(table.projectId, [...opts.projectIds]) : void 0
+    )).orderBy(sql`rowid`).limit(BATCH_SIZE).all();
+    if (rows.length === 0) break;
+    lastRowid = rows[rows.length - 1].rowid;
+    result.examined += rows.length;
+    for (const row of rows) {
+      if (!isScannerPath(row.path)) continue;
+      result.probes++;
+      const id = JSON.stringify([row.projectId, row.sourceId, row.correlationKey]);
+      const client = clients.get(id) ?? { projectId: row.projectId, sourceId: row.sourceId, correlationKey: row.correlationKey, probes: [] };
+      client.probes.push(Date.parse(row.ts));
+      clients.set(id, client);
+    }
+    await yieldToEventLoop();
+  }
+  for (const client of clients.values()) {
+    if (opts.shouldStop()) break;
+    const probes = client.probes.sort((a, b) => a - b);
+    const from = new Date(probes[0] - SCANNER_BURST_WINDOW_MS).toISOString();
+    const to = new Date(probes.at(-1) + SCANNER_BURST_WINDOW_MS).toISOString();
+    db.transaction((tx) => {
+      const rows = tx.select().from(table).where(and(
+        eq(table.projectId, client.projectId),
+        eq(table.sourceId, client.sourceId),
+        eq(table.correlationKey, client.correlationKey),
+        gte(table.ts, from),
+        lte(table.ts, to),
+        ne(table.trust, AgentTrustLevels.verified)
+      )).all();
+      for (const row of rows) {
+        const probe = isScannerPath(row.path);
+        const at = Date.parse(row.ts);
+        if (!probe && !probes.some((t) => Math.abs(at - t) <= SCANNER_BURST_WINDOW_MS)) continue;
+        result.removed++;
+        if (opts.dryRun) continue;
+        tx.delete(table).where(eq(table.id, row.id)).run();
+        tx.update(agentJourneyCaptureDays).set({ storedEvents: sql`max(${agentJourneyCaptureDays.storedEvents} - 1, 0)` }).where(and(
+          eq(agentJourneyCaptureDays.projectId, row.projectId),
+          eq(agentJourneyCaptureDays.sourceId, row.sourceId),
+          eq(agentJourneyCaptureDays.day, row.ts.slice(0, 10))
+        )).run();
+        if (!probe) moveAgentHitToBurst(tx, row, opts.now);
+      }
+    }, { behavior: "immediate" });
+    await yieldToEventLoop();
+  }
+  return result;
+}
+async function reclassifyStoredTraffic(db, opts = {}) {
+  const shared = {
+    projectIds: opts.projectIds,
+    dryRun: opts.dryRun === true,
+    now: opts.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    shouldStop: opts.shouldStop ?? (() => false)
+  };
+  const samples = await reclassifyUnknownSamples(db, shared);
+  const unrecognized = shared.shouldStop() ? { examined: 0, moved: 0, movedHits: 0, renamed: 0, removed: 0, byBot: {} } : await reclassifyUnrecognizedRows(db, shared);
+  const agentHits = shared.shouldStop() ? { examined: 0, moved: 0, movedHits: 0 } : await reassessAgentHits(db, shared);
+  const agentRequests = shared.shouldStop() ? { examined: 0, probes: 0, removed: 0 } : await reassessAgentRequests(db, shared);
+  const journeys = shared.shouldStop() ? { visitors: 0, visitorsRemoved: 0, visitsRemoved: 0, visitsRelanded: 0 } : correctBackgroundCallJourneys(db, shared);
+  const journeyMerges = shared.shouldStop() ? { visitorsMerged: 0, visitsJoined: 0 } : mergeSplitJourneyVisitors(db, shared);
+  return { dryRun: shared.dryRun, samples, unrecognized, agentHits, agentRequests, journeys, journeyMerges };
+}
+async function reclassifyStoredTrafficIfRulesChanged(db, opts = {}) {
+  const fingerprint = trafficClassificationFingerprint();
+  const state = db.select().from(trafficReclassificationState).where(eq(trafficReclassificationState.id, STATE_ID)).get();
+  if (state?.fingerprint === fingerprint) return { ran: false };
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const shouldStop = opts.shouldStop ?? (() => false);
+  const result = await reclassifyStoredTraffic(db, { now: now(), shouldStop });
+  if (shouldStop()) return { ran: false };
+  const completedAt = now();
+  db.insert(trafficReclassificationState).values({ id: STATE_ID, fingerprint, completedAt, resultJson: { ...result } }).onConflictDoUpdate({
+    target: trafficReclassificationState.id,
+    set: { fingerprint, completedAt, resultJson: { ...result } }
+  }).run();
+  return { ran: true, result };
+}
+function startTrafficReclassification(opts) {
+  let stopped = false;
+  const timer = setTimeout(() => {
+    reclassifyStoredTrafficIfRulesChanged(opts.db, { shouldStop: () => stopped }).then((outcome) => {
+      if (!outcome.ran || !outcome.result) return;
+      const { samples, unrecognized, agentHits, agentRequests, journeys, journeyMerges } = outcome.result;
+      log.info("traffic-reclassify.completed", {
+        samplesReclassified: samples.reclassified,
+        samplesCounted: samples.counted,
+        samplesRemoved: samples.removed,
+        unrecognizedMoved: unrecognized.moved,
+        unrecognizedMovedHits: unrecognized.movedHits,
+        unrecognizedRenamed: unrecognized.renamed,
+        unrecognizedRemoved: unrecognized.removed,
+        agentHitsMoved: agentHits.movedHits,
+        agentRequestsRemoved: agentRequests.removed,
+        journeyVisitorsRemoved: journeys.visitorsRemoved,
+        journeyVisitsRemoved: journeys.visitsRemoved,
+        journeyVisitsRelanded: journeys.visitsRelanded,
+        journeyVisitorsMerged: journeyMerges.visitorsMerged,
+        journeyVisitsJoined: journeyMerges.visitsJoined
+      });
+    }).catch((err) => {
+      if (!stopped) log.error("traffic-reclassify.failed", { error: describeError(err) });
+    });
+  }, opts.delayMs ?? TRAFFIC_RECLASSIFY_START_DELAY_MS);
+  timer.unref();
+  return () => {
+    stopped = true;
+    clearTimeout(timer);
+  };
+}
+
 export {
   OPENAI_RETRIEVAL_CONTRACT,
   reparseStoredResult,
@@ -2911,5 +3428,7 @@ export {
   museAdapter,
   openrouterAdapter,
   resolveStoredApiResponse,
-  extractStoredAnswerAnchors
+  extractStoredAnswerAnchors,
+  reclassifyStoredTraffic,
+  startTrafficReclassification
 };

package/dist/{chunk-SEAXXCU6.js → chunk-4KK3OTHE.js}

@@ -5,7 +5,7 @@ import {
   AppError,
   parseWindowIn,
   resolveDateRange
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-KNKOTLVW.js";
 
 // src/cli-access.ts
 var CLI_ACCESS_BY_ID = Object.freeze({

package/dist/{chunk-X7U7XYJQ.js → chunk-5NEZO3SC.js}

@@ -3,7 +3,7 @@ import {
   resolveCliAccess,
   resolveCliAccessForInvocation,
   windowOptions
-} from "./chunk-SEAXXCU6.js";
+} from "./chunk-4KK3OTHE.js";
 import {
   emitJsonl
 } from "./chunk-Z7IUAJOF.js";
@@ -14,7 +14,7 @@ import {
 } from "./chunk-HGMYEDAQ.js";
 import {
   OperationAccesses
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-KNKOTLVW.js";
 
 // src/cli-catalog.ts
 import { createRequire } from "module";
@@ -111,7 +111,7 @@ async function dispatchRegisteredCommand(args, fallbackFormat, specs) {
     const accessValue = accessFilterFromArgs(argsWithoutHelp);
     validateAccessFilter(accessValue);
     if (fallbackFormat !== "text") {
-      const { printCliCatalog: printCliCatalog2 } = await import("./cli-catalog-IKF4A7ZS.js");
+      const { printCliCatalog: printCliCatalog2 } = await import("./cli-catalog-QVCJWPCI.js");
       const group2 = argsWithoutHelp.find((arg) => !arg.startsWith("--"));
       printCliCatalog2(specs, fallbackFormat, group2, accessValue);
       return true;

package/dist/{chunk-SVMTN7MI.js → chunk-6SGHSSWQ.js}

@@ -1,11 +1,11 @@
 import {
   getRequestContext
-} from "./chunk-WDEDEEWA.js";
+} from "./chunk-PX2KVGOJ.js";
 import {
   diagnosticIdentity,
   redactLogString,
   redactLogValue
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-KNKOTLVW.js";
 
 // ../api-routes/src/runtime-logger.ts
 import { format } from "util";

package/dist/{chunk-NCM6PX64.js → chunk-AICFUZ6X.js}

@@ -28,7 +28,7 @@ import {
   unknownUsageObservation,
   usdToMicros,
   withRetry
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-KNKOTLVW.js";
 
 // ../provider-answer-services/src/core/http.ts
 var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;

package/dist/{chunk-QAJDHHC5.js → chunk-BQTXXXUG.js}

@@ -1,6 +1,6 @@
 import {
   cloudflareQueueNameSchema
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-KNKOTLVW.js";
 
 // src/cloudflare-traffic-config.ts
 function unsupportedDeliveryMode(deliveryMode) {