@canonry/canonry 7.83.1 → 7.84.0

package/dist/{chunk-X7U7XYJQ.js → chunk-6TLHA6XA.js}

@@ -3,7 +3,7 @@ import {
   resolveCliAccess,
   resolveCliAccessForInvocation,
   windowOptions
-} from "./chunk-SEAXXCU6.js";
+} from "./chunk-VCUNNS4R.js";
 import {
   emitJsonl
 } from "./chunk-Z7IUAJOF.js";
@@ -14,7 +14,7 @@ import {
 } from "./chunk-HGMYEDAQ.js";
 import {
   OperationAccesses
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.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-JTIC72BY.js");
       const group2 = argsWithoutHelp.find((arg) => !arg.startsWith("--"));
       printCliCatalog2(specs, fallbackFormat, group2, accessValue);
       return true;

package/dist/{chunk-7Q5BSCKN.js → chunk-6Y75QV2S.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-VJWDBFSL.js";
 import {
   createApiClient
-} from "./chunk-IPPNN5KE.js";
+} from "./chunk-AAKRCOQV.js";
 import {
   CliError,
   isMachineFormat
 } from "./chunk-HGMYEDAQ.js";
 import {
   describeError
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/commands/mcp.ts
 import fs from "fs";

package/dist/{chunk-IPPNN5KE.js → chunk-AAKRCOQV.js}

@@ -1,6 +1,6 @@
 import {
   loadConfig
-} from "./chunk-WA4FD5Y6.js";
+} from "./chunk-WR4PA335.js";
 import {
   PACKAGE_VERSION
 } from "./chunk-AOJU5LKX.js";
@@ -36,7 +36,7 @@ import {
   sentimentSettingsReadSchema,
   sentimentSummaryReadSchema,
   upgradeCommandFor
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // ../api-client-generated/src/generated/core/bodySerializer.gen.ts
 var jsonBodySerializer = {

package/dist/{chunk-OMNS42ZQ.js → chunk-B42R2SPU.js}

@@ -1,9 +1,36 @@
 import {
-  parseJsonColumn
-} from "./chunk-3UFQI4KL.js";
+  createLogger
+} from "./chunk-WJITVHAU.js";
+import {
+  addLikelyFakeAgentHits,
+  writeUnrecognizedAgentBuckets
+} from "./chunk-6SVAUILQ.js";
+import {
+  BROWSER_SHAPED_AGENT_MARKERS,
+  DEFAULT_AI_CRAWLER_RULES,
+  GENERIC_HTTP_CLIENTS,
+  SELF_TRAFFIC_USER_AGENT_PATTERNS,
+  UNLISTED_AGENT_SKIPPED_EXTENSIONS,
+  UNRECOGNIZED_AGENT_NAMING_VERSION,
+  classifyAiUserFetch,
+  classifyCrawler,
+  isSelfTraffic,
+  unrecognizedAgentName
+} from "./chunk-O7TWL6ZH.js";
+import {
+  RawEventSampleEventTypes,
+  aiUserFetchEventsHourly,
+  crawlerEventsHourly,
+  migrationsTable,
+  parseJsonColumn,
+  rawEventSamples,
+  trafficReclassificationState,
+  unrecognizedAgentEventsHourly
+} from "./chunk-BIGIIVGV.js";
 import {
   AI_ENGINE_DOMAINS,
   AI_ENGINE_SELF_DOMAINS,
+  AgentTrustLevels,
   AnchoredSpanSources,
   OPENROUTER_MODEL_PATTERN,
   OPENROUTER_ROUTE_FAMILY,
@@ -12,6 +39,10 @@ import {
   ProviderNames,
   RetrievalContracts,
   RetrievalStatuses,
+  TrafficEventConfidences,
+  TrafficEvidenceKinds,
+  TrafficSourceTypes,
+  UNRECORDED_TRAFFIC_PATH,
   VERTEX_AI_SEARCH_PROXY_DOMAIN,
   asRecord,
   describeError,
@@ -26,7 +57,7 @@ import {
   retryAfterDelayMs,
   usageCount,
   withRetry
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // ../provider-openai/src/normalize.ts
 import OpenAI from "openai";
@@ -2895,6 +2926,310 @@ function extractStoredAnswerAnchors(provider, rawResponse) {
   }
 }
 
+// src/traffic-reclassify.ts
+import { createHash } from "crypto";
+import { setImmediate as yieldToEventLoop } from "timers/promises";
+import { and, eq, inArray, 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,
+    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;
+}
+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);
+  return { dryRun: shared.dryRun, samples, unrecognized };
+}
+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 } = 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
+      });
+    }).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 +3246,7 @@ export {
   museAdapter,
   openrouterAdapter,
   resolveStoredApiResponse,
-  extractStoredAnswerAnchors
+  extractStoredAnswerAnchors,
+  reclassifyStoredTraffic,
+  startTrafficReclassification
 };

package/dist/{chunk-3UFQI4KL.js → chunk-BIGIIVGV.js}

@@ -20,7 +20,7 @@ import {
   templateLinkRatio,
   templateLinkUbiquityAvailable,
   validationError
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -176,6 +176,7 @@ __export(schema_exports, {
   siteCrawlSnapshots: () => siteCrawlSnapshots,
   siteLivenessState: () => siteLivenessState,
   trafficEventReceipts: () => trafficEventReceipts,
+  trafficReclassificationState: () => trafficReclassificationState,
   trafficSources: () => trafficSources,
   unrecognizedAgentEventsHourly: () => unrecognizedAgentEventsHourly,
   unrecognizedAgentNotifyState: () => unrecognizedAgentNotifyState,
@@ -2596,6 +2597,12 @@ var unrecognizedAgentNotifyState = sqliteTable2("unrecognized_agent_notify_state
 }, (table) => [
   primaryKey2({ columns: [table.projectId, table.agentName] })
 ]);
+var trafficReclassificationState = sqliteTable2("traffic_reclassification_state", {
+  id: text2("id").primaryKey(),
+  fingerprint: text2("fingerprint").notNull(),
+  completedAt: text2("completed_at").notNull(),
+  resultJson: text2("result_json", { mode: "json" }).$type()
+});
 var aiReferralEventsHourly = sqliteTable2("ai_referral_events_hourly", {
   projectId: text2("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
   sourceId: text2("source_id").notNull().references(() => trafficSources.id, { onDelete: "cascade" }),
@@ -8538,6 +8545,18 @@ var MIGRATION_VERSIONS = [
       `CREATE INDEX IF NOT EXISTS idx_ai_user_fetch_likely_fake_project_ts ON ai_user_fetch_likely_fake_hourly(project_id, ts_hour)`,
       `CREATE INDEX IF NOT EXISTS idx_ai_user_fetch_likely_fake_source_ts ON ai_user_fetch_likely_fake_hourly(source_id, ts_hour)`
     ]
+  },
+  {
+    version: 204,
+    name: "traffic-reclassification-state",
+    statements: [
+      `CREATE TABLE IF NOT EXISTS traffic_reclassification_state (
+        id            TEXT PRIMARY KEY,
+        fingerprint   TEXT NOT NULL,
+        completed_at  TEXT NOT NULL,
+        result_json   TEXT
+      )`
+    ]
   }
 ];
 var AERO_LEDGER_REBUILDS = [
@@ -10046,6 +10065,7 @@ export {
   aiUserFetchVerificationManifestsHourly,
   unrecognizedAgentEventsHourly,
   unrecognizedAgentNotifyState,
+  trafficReclassificationState,
   aiReferralEventsHourly,
   rawEventSamples,
   RawEventSampleEventTypes,

package/dist/{chunk-W5ZBMBBZ.js → chunk-CEOIGQTS.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-HGMYEDAQ.js";
 import {
   describeError
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/gsc-sitemap-submission.ts
 function dedupeGscSitemapUrls(urls) {

package/dist/{chunk-WDEDEEWA.js → chunk-D37PJYLD.js}

@@ -1,7 +1,7 @@
 import {
   USAGE_TELEMETRY_HEADERS,
   redactLogString
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // ../api-routes/src/request-context.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-M3FWZMO4.js → chunk-EMSZDVDP.js}

@@ -1,9 +1,9 @@
-import {
-  createLogger
-} from "./chunk-SVMTN7MI.js";
 import {
   pickProjectCitedDomain
-} from "./chunk-LZGVQSZL.js";
+} from "./chunk-43CPBLRJ.js";
+import {
+  createLogger
+} from "./chunk-WJITVHAU.js";
 import {
   GBP_INSIGHT_PROVIDER,
   PERSISTENT_GAP_THRESHOLD,
@@ -17,7 +17,7 @@ import {
   mergeGscQueryTotalsWithFallback,
   readGscQueryDailyRows,
   readLatestGscDataDate
-} from "./chunk-ZDOT2XF2.js";
+} from "./chunk-6SVAUILQ.js";
 import {
   competitors,
   gbpDailyMetrics,
@@ -35,14 +35,14 @@ import {
   queries,
   querySnapshots,
   runs
-} from "./chunk-3UFQI4KL.js";
+} from "./chunk-BIGIIVGV.js";
 import {
   CitationStates,
   RunKinds,
   RunStatuses,
   RunTriggers,
   effectiveDomains
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/intelligence-service.ts
 import { eq, desc, asc, and, ne, or, inArray, gte, lte, isNull, sql, exists } from "drizzle-orm";

package/dist/{chunk-32U5LFIT.js → chunk-GJE3OG4Y.js}

@@ -7,12 +7,12 @@ import {
 import {
   createApiClient,
   runWithUsageTags
-} from "./chunk-IPPNN5KE.js";
+} from "./chunk-AAKRCOQV.js";
 import {
   canonryMcpTools,
   mcpOutputSchema,
   toolOperationAccess
-} from "./chunk-HIC62JTS.js";
+} from "./chunk-ZRL5FO5G.js";
 import {
   PACKAGE_VERSION
 } from "./chunk-AOJU5LKX.js";
@@ -25,7 +25,7 @@ import {
   isReadOnlyKey,
   restrictedWriteScopes,
   upgradeCaveatFor
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/mcp/server.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-JCWXEVYW.js → chunk-HYEPL5UY.js}

@@ -1,13 +1,13 @@
 import {
   createApiClient
-} from "./chunk-IPPNN5KE.js";
+} from "./chunk-AAKRCOQV.js";
 import {
   emitJsonl
 } from "./chunk-Z7IUAJOF.js";
 import {
   measurementDraftOperationSchema,
   runMeasurementDraftAction
-} from "./chunk-KFMU6CLU.js";
+} from "./chunk-LYNYNNOD.js";
 import {
   isMachineFormat,
   systemError
@@ -37,7 +37,7 @@ import {
   unattributedAnswersLabel,
   uncheckedSourcesLabel,
   visibilityReportRequestSchema
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/commands/measurement-plan.ts
 import crypto from "crypto";

package/dist/{chunk-KCFIQJOL.js → chunk-I642VITF.js}

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-IPPNN5KE.js";
+} from "./chunk-AAKRCOQV.js";
 import {
   emitJsonl
 } from "./chunk-Z7IUAJOF.js";
@@ -19,7 +19,7 @@ import {
   formatMicros,
   formatRunErrorOneLine,
   resolveProviderInput
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/commands/run.ts
 function getClient() {

package/dist/{chunk-PHVIMUAQ.js → chunk-K3OY52MI.js}

@@ -25423,9 +25423,10 @@ var DOWNLOAD_EXTENSIONS = /* @__PURE__ */ new Set([
   "sql"
 ]);
 var SITEMAP_BASENAME = /^sitemap(?:[-_]index)?$/;
+var UNRECORDED_TRAFFIC_PATH = "(path not recorded)";
 function classifyTrafficPath(pathNormalized) {
   const raw = (pathNormalized ?? "").trim();
-  if (!raw) return TrafficPathClasses.other;
+  if (!raw || raw === UNRECORDED_TRAFFIC_PATH) return TrafficPathClasses.other;
   const rawPath = raw.split(/[?#]/)[0] ?? "";
   const pathOnly = rawPath.length > 1 ? rawPath.replace(/\/+$/, "") || "/" : rawPath;
   if (!pathOnly) return TrafficPathClasses.other;
@@ -27888,6 +27889,7 @@ export {
   agentJourneysResponseSchema,
   agentJourneyDetailResponseSchema,
   TrafficPathClasses,
+  UNRECORDED_TRAFFIC_PATH,
   classifyTrafficPath,
   segmentCrawlerHits,
   sumInfraHits,

package/dist/{chunk-YJOGWS7F.js → chunk-LE6ZODCY.js}

@@ -5,7 +5,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-WA4FD5Y6.js";
+} from "./chunk-WR4PA335.js";
 import {
   CANONRY_NPM_PACKAGE_URL,
   compareSemver,
@@ -18,7 +18,7 @@ import {
   updateCheckEnvOptOut,
   upgradeCaveatFor,
   upgradeCommandFor
-} from "./chunk-PHVIMUAQ.js";
+} from "./chunk-K3OY52MI.js";
 
 // src/runtime-context.ts
 function cliRuntimeContext(env = process.env, stdio = process) {

package/dist/{chunk-YCRPOY2Y.js → chunk-LHAD6EK3.js}

@@ -1,9 +1,9 @@
 import {
   trackIntegrationConnection
-} from "./chunk-P76XOEWL.js";
+} from "./chunk-UYR5JI6R.js";
 import {
   cliRuntimeContext
-} from "./chunk-YJOGWS7F.js";
+} from "./chunk-LE6ZODCY.js";
 
 // src/cli-connection-telemetry.ts
 function trackCliConnection(properties) {