@canonry/canonry 7.7.0 → 7.8.0

package/dist/{chunk-LFUSODDL.js → chunk-L35TGPAV.js}

@@ -20,20 +20,20 @@ import {
   saveConfig,
   saveConfigPatch,
   sentimentInstallReadiness
-} from "./chunk-WBTYXLXL.js";
+} from "./chunk-LO56QXPO.js";
 import {
   computeFactorAverages,
   deleteSiteCrawlGraphLayout,
   persistSiteCrawlGraphLayout,
   prepareSiteCrawlGraphLayout,
   recordedSharePct
-} from "./chunk-JJXTHJ4E.js";
+} from "./chunk-T2V2PESH.js";
 import {
   CanonryMcpToolNames,
   CliError,
   PACKAGE_VERSION,
   canonryMcpTools
-} from "./chunk-3DB43KT2.js";
+} from "./chunk-ZLB7WX5D.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -205,7 +205,7 @@ import {
   siteLivenessState,
   toAlertView,
   usageCounters
-} from "./chunk-75RSUOHZ.js";
+} from "./chunk-KRFTA4I7.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_NONE,
@@ -238,6 +238,7 @@ import {
   LlmCapabilities,
   MEASUREMENT_CHANGES_NOISE_ANSWERS,
   MEASUREMENT_PLAN_V2_SCHEMA_VERSION,
+  MeasurementPortfolioLists,
   MemorySources,
   ONBOARDING_FLOW_VERSION,
   OUTSTANDING_PROVIDER_BATCH_STATUSES,
@@ -403,6 +404,7 @@ import {
   templateLinkUbiquityAvailable,
   textContainsBrandAlias,
   textContainsDomain,
+  truncateUtf16,
   updateCheckEnvOptOut,
   upgradeCaveatFor,
   upgradeCommandFor,
@@ -412,7 +414,7 @@ import {
   visibilityReportRequestSchema,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-WJJTKZKK.js";
+} from "./chunk-DO7XPDG5.js";
 
 // src/runtime-context.ts
 function cliRuntimeContext(env = process.env, stdio = process) {
@@ -7870,7 +7872,7 @@ function nonBlank(value) {
   return trimmed ? trimmed : void 0;
 }
 function resolveBuildCommit(env = process.env) {
-  const embedded = true ? "0860f29cce58a29483357e3fd66869877e7a393c" : void 0;
+  const embedded = true ? "6f387d86ae72c2505e9c3d5f17e1bc7f45397872" : void 0;
   return nonBlank(embedded) ?? nonBlank(env.CANONRY_COMMIT);
 }
 function resolveInstanceIdentity(env = process.env) {
@@ -16262,7 +16264,7 @@ import { Type as Type3 } from "@earendil-works/pi-ai";
 
 // src/agent/mcp-to-agent-tool.ts
 import { Type as Type2 } from "@earendil-works/pi-ai";
-import { randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID2 } from "crypto";
 
 // src/agent/tool-result-units.ts
 var SUCCESS_STATUSES = ["200", "201", "202"];
@@ -16353,16 +16355,25 @@ function renderRatioUnits(schema, value, components = {}) {
 
 // src/agent/mcp-to-agent-tool.ts
 var MAX_TOOL_RESULT_CHARS = 2e4;
-var TRUNCATION_NOTE = "... (truncated, result too large)";
 var TRUNCATION_SUMMARY_KEY = "__truncation";
 var PARTIAL_LISTS_KEY = "__partialLists";
 var CURSOR_KEYS = ["nextCursor", "nextOffset", "nextPageToken", "next_cursor"];
+var PORTFOLIO_PAGE_LISTS = /* @__PURE__ */ new Map([
+  [MeasurementPortfolioLists["weakest-properties"], { path: "weakestProperties", totalKey: "totalProperties" }],
+  [MeasurementPortfolioLists["strongest-mentions"], { path: "mentionRanking.strongest", totalKey: "eligiblePropertyCount" }],
+  [MeasurementPortfolioLists["weakest-mentions"], { path: "mentionRanking.weakest", totalKey: "eligiblePropertyCount" }],
+  [MeasurementPortfolioLists["excluded-mentions"], { path: "mentionRanking.excluded", totalKey: "excludedTotal" }],
+  [MeasurementPortfolioLists.markets, { path: "markets", totalKey: "totalMarkets" }],
+  [MeasurementPortfolioLists["observed-names"], { path: "answerEvidence.observedNames", totalKey: "observedNamesTotal" }],
+  [MeasurementPortfolioLists["cited-domains"], { path: "answerEvidence.citedDomains", totalKey: "citedDomainsTotal" }]
+]);
 var MAX_STRUCTURED_TRUNCATION_CHARS = 2e6;
 var TRUNCATION_SERIALIZE_BUDGET_CHARS = 64e6;
 var SMALL_LIST_ROWS = 25;
-var MAX_SUMMARY_DEPTH = 5;
 var MAX_SUMMARY_KEYS = 30;
-var MAX_SUMMARY_SEGMENT_CHARS = 60;
+var MAX_SUMMARY_PATH_CHARS = 96;
+var PROJECTION_SUMMARY_CHARS = 5e3;
+var PROJECTION_METADATA_CHARS = PROJECTION_SUMMARY_CHARS - 500;
 var MAX_PARTIAL_DEPTH = 4;
 var MAX_PARTIAL_NOTES = 12;
 function serializeResult(value) {
@@ -16381,10 +16392,47 @@ function keptSummary(counts, cursors = {}) {
   if (Object.keys(cursors).length > 0) summary.cursors = cursors;
   return summary;
 }
-function noteCursor(owner, ownerPath, listPath, kept, total, notes) {
-  const key = CURSOR_KEYS.find((candidate) => owner[candidate] !== void 0 && owner[candidate] !== null);
-  if (!key || kept >= total) return;
-  notes[ownerPath ? `${ownerPath}.${key}` : key] = `skips the ${total - kept} rows cut from ${listPath}; to read them, call again with ${kept > 0 ? `limit <= ${kept}` : "a lower limit"}`;
+function noteCursor(owner, ownerPath, listPath, kept, total, notes, root = owner) {
+  const cursor = cursorForList(owner, ownerPath, listPath.slice(listPath.lastIndexOf(".") + 1), root);
+  if (!cursor || kept >= total) return;
+  notes[cursor.path] = `incomplete page: skips the ${total - kept} rows cut from ${listPath}; re-request the original cursor with ${kept > 0 ? `${cursor.limit} <= ${kept}` : `a lower ${cursor.limit}`}`;
+}
+function cursorForList(owner, ownerPath, listKey, root = owner) {
+  const prefix = ownerPath ? `${ownerPath}.` : "";
+  if (listKey === "queries" && isRecord5(owner.queryPage) && owner.queryPage.nextCursor !== void 0 && owner.queryPage.nextCursor !== null) {
+    const page = owner.queryPage;
+    return {
+      path: `${prefix}queryPage.nextCursor`,
+      value: page.nextCursor,
+      parameter: "queryCursor",
+      limit: "queryLimit",
+      ...typeof page.total === "number" ? { total: { count: page.total, text: String(page.total) } } : {}
+    };
+  }
+  if (listKey === "attempts" && owner.nextAttemptCursor !== void 0 && owner.nextAttemptCursor !== null) {
+    return {
+      path: `${prefix}nextAttemptCursor`,
+      value: owner.nextAttemptCursor,
+      parameter: "attemptCursor",
+      limit: "attemptLimit",
+      ...typeof owner.attemptCount === "number" ? { total: { count: owner.attemptCount, text: String(owner.attemptCount) } } : {}
+    };
+  }
+  const selected = typeof root.pageList === "string" ? PORTFOLIO_PAGE_LISTS.get(root.pageList) : void 0;
+  const selectedList = selected?.path === `${prefix}${listKey}`;
+  if (selected && owner === root && !selectedList) return void 0;
+  const cursorOwner = selectedList ? root : owner;
+  const cursorPrefix = selectedList ? "" : prefix;
+  const key = CURSOR_KEYS.find((candidate) => cursorOwner[candidate] !== void 0 && cursorOwner[candidate] !== null);
+  if (!key) return void 0;
+  const total = selectedList ? owner[selected.totalKey] : void 0;
+  return {
+    path: `${cursorPrefix}${key}`,
+    value: cursorOwner[key],
+    parameter: "cursor",
+    limit: "limit",
+    ...typeof total === "number" ? { total: { count: total, text: String(total) } } : {}
+  };
 }
 function ownListTotal(numbers, key) {
   const lower = key.toLowerCase();
@@ -16412,9 +16460,14 @@ function partialLists(root) {
     }
     let noted = false;
     if (lists.length <= MAX_SUMMARY_KEYS) {
-      const counts = lists.map(([key]) => ownListTotal(numbers, key));
+      const counts = lists.map(([key]) => ownListTotal(numbers, key) ?? cursorForList(object, path9, key, root)?.total);
       const uncounted = counts.flatMap((count3, index) => count3 ? [] : [index]);
-      if (uncounted.length === 1) counts[uncounted[0]] = bareTotal(numbers);
+      if (uncounted.length === 1) {
+        const index = uncounted[0];
+        const key = lists[index][0];
+        const paged = cursorForList(object, path9, key, root) || typeof object.truncated === "boolean" || typeof object[`${key}Truncated`] === "boolean" || ["items", "rows", "results"].includes(key);
+        if (paged) counts[index] = bareTotal(numbers);
+      }
       for (const [index, [key, rows]] of lists.entries()) {
         const label = path9 ? `${path9}.${key}` : key;
         const count3 = counts[index];
@@ -16442,9 +16495,25 @@ function withPartialLists(value) {
   if (!isRecord5(value) || typeof value.toJSON === "function") return value;
   const hadNote = Object.hasOwn(value, PARTIAL_LISTS_KEY);
   const notes = partialLists(value);
-  if (!notes && !hadNote) return value;
-  const { [PARTIAL_LISTS_KEY]: _previous, ...rest } = value;
-  return notes ? { [PARTIAL_LISTS_KEY]: notes, ...rest } : rest;
+  if (!notes && !hadNote && value.nextAttemptCursor == null && !CURSOR_KEYS.some((key) => value[key] !== void 0 && value[key] !== null) && !Object.values(value).some((child) => isRecord5(child) && CURSOR_KEYS.some((key) => child[key] !== void 0 && child[key] !== null))) return value;
+  const pagination = {};
+  const visit = (owner, path9, depth) => {
+    const lists = Object.entries(owner).filter((entry) => Array.isArray(entry[1]));
+    const numbers = Object.entries(owner).filter((entry) => typeof entry[1] === "number");
+    for (const [key, rows] of lists) {
+      const cursor = cursorForList(owner, path9, key, value);
+      if (!cursor || key.startsWith("__") || Object.keys(pagination).length >= MAX_PARTIAL_NOTES) continue;
+      const label = path9 ? `${path9}.${key}` : key;
+      const total = cursor.total ?? ownListTotal(numbers, key) ?? (lists.length === 1 ? bareTotal(numbers) : void 0);
+      const incomplete = owner.__truncated === true || isRecord5(owner.__omittedRowsByField) && typeof owner.__omittedRowsByField[key] === "number";
+      pagination[label] = `showing ${rows.length}${total ? ` of ${total.text}` : " rows"}; ${incomplete ? `incomplete page: re-request the original cursor with a smaller ${cursor.limit}; the next cursor skips omitted rows` : `pass ${cursor.parameter} ${JSON.stringify(cursor.value)}`}`;
+    }
+    if (depth >= MAX_PARTIAL_DEPTH) return;
+    for (const [key, child] of Object.entries(owner)) if (!key.startsWith("__") && isRecord5(child)) visit(child, path9 ? `${path9}.${key}` : key, depth + 1);
+  };
+  visit(value, "", 1);
+  const { [PARTIAL_LISTS_KEY]: _previous, __pagination: _pagination, ...rest } = value;
+  return { ...notes ? { [PARTIAL_LISTS_KEY]: notes } : {}, ...Object.keys(pagination).length > 0 ? { __pagination: pagination } : {}, ...rest };
 }
 function largestArrayKey(obj) {
   let best;
@@ -16569,7 +16638,7 @@ function currentSummary(root, owned) {
           count3.kept += value.length;
           count3.total += list.rows.length;
           counts.set(list.path, count3);
-          noteCursor(object, path9, list.path, value.length, list.rows.length, cursors);
+          noteCursor(object, path9, list.path, value.length, list.rows.length, cursors, root);
         }
         for (const row of value) if (isRecord5(row)) visit(row, `${valuePath}[]`);
       } else if (isRecord5(value)) {
@@ -16672,123 +16741,107 @@ function hasOtherLists(value, primary) {
   }
   return isRecord5(value) && Object.values(value).some((child) => hasOtherLists(child, primary));
 }
-function shortSegment(key) {
-  return key.length > MAX_SUMMARY_SEGMENT_CHARS ? `${key.slice(0, MAX_SUMMARY_SEGMENT_CHARS)}...` : key;
-}
-function childPath(container) {
-  if (container.kind === "array") return `${container.path}[${container.complete}]`;
-  const key = shortSegment(container.key ?? "");
-  return container.path ? `${container.path}.${key}` : key;
-}
-function serializedKeys(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const record2 = value;
-  if (typeof record2.toJSON === "function") return void 0;
-  return Object.keys(record2).filter((key) => {
-    const child = record2[key];
-    return child !== void 0 && typeof child !== "function" && typeof child !== "symbol";
-  });
+function projectionPath(path9) {
+  if (path9.length <= MAX_SUMMARY_PATH_CHARS) return path9;
+  const digest = createHash5("sha256").update(path9).digest("hex").slice(0, 12);
+  return `${truncateUtf16(path9, 48)}...#${digest}${path9.slice(-24)}`;
 }
-function openContainersAt(shown, details) {
-  const stack = [];
-  let inString = false;
-  let escaped = false;
-  let stringStart = 0;
-  for (let i = 0; i < shown.length; i++) {
-    const ch = shown[i];
-    const top = stack.at(-1);
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (ch === "\\") escaped = true;
-      else if (ch === '"') {
-        inString = false;
-        if (top?.kind === "object" && top.expectKey) {
-          top.key = JSON.parse(shown.slice(stringStart, i + 1));
-          top.expectKey = false;
+function boundedProjection(full) {
+  const value = JSON.parse(full);
+  const summary = {
+    droppedKeys: [],
+    keptItems: {},
+    projection: "Only complete array rows and marked partial string prefixes are shown; omitted fields are not evidence. Never follow a cursor from a cut page; re-request the original cursor with a smaller limit."
+  };
+  const skippedMetadata = () => {
+    summary.moreMetadataEntries = (summary.moreMetadataEntries ?? 0) + 1;
+  };
+  const record2 = (entries, path9, value2) => {
+    if (Object.keys(entries).length >= MAX_SUMMARY_KEYS) {
+      skippedMetadata();
+      return false;
+    }
+    const key = projectionPath(path9);
+    entries[key] = value2;
+    if (serializeResult(summary).length <= PROJECTION_METADATA_CHARS) return true;
+    delete entries[key];
+    skippedMetadata();
+    return false;
+  };
+  let dropped = 0;
+  const omit = (path9) => {
+    dropped++;
+    if (summary.droppedKeys.length < MAX_SUMMARY_KEYS) {
+      summary.droppedKeys.push(projectionPath(path9));
+      if (serializeResult(summary).length > PROJECTION_METADATA_CHARS) summary.droppedKeys.pop();
+    }
+    if (dropped > summary.droppedKeys.length) summary.moreDroppedKeys = dropped - summary.droppedKeys.length;
+  };
+  const project = (input, budget, path9, owner, ownerPath = "") => {
+    if (Array.isArray(input)) {
+      const rows = [];
+      let used2 = 2;
+      for (const row of input) {
+        const text = serializeResult(row);
+        const cost = text.length + (rows.length > 0 ? 1 : 0);
+        if (used2 + cost > budget) break;
+        rows.push(text);
+        used2 += cost;
+      }
+      if (rows.length < input.length) {
+        record2(summary.keptItems, path9 || "items", `${rows.length} of ${input.length}`);
+        if (rows.length === 0) omit(path9 || "items");
+        if (owner) {
+          const cursors = {};
+          noteCursor(owner, ownerPath, path9, rows.length, input.length, cursors, isRecord5(value) ? value : owner);
+          for (const [cursor, note] of Object.entries(cursors)) {
+            record2(summary.cursors ??= {}, cursor, note.replace(path9, projectionPath(path9)));
+          }
         }
       }
-      continue;
+      return `[${rows.join(",")}]`;
     }
-    if (ch === '"') {
-      inString = true;
-      stringStart = i;
-    } else if (ch === "{" || ch === "[") {
-      let value = details;
-      if (top) {
-        const parent = top.value;
-        value = top.kind === "array" ? Array.isArray(parent) ? parent[top.complete] : void 0 : parent && typeof parent === "object" ? parent[top.key ?? ""] : void 0;
-      }
-      stack.push({
-        kind: ch === "{" ? "object" : "array",
-        path: top ? childPath(top) : "",
-        value,
-        complete: 0,
-        childClosed: false,
-        expectKey: ch === "{"
-      });
-    } else if (ch === "}" || ch === "]") {
-      stack.pop();
-      const parent = stack.at(-1);
-      if (parent) parent.childClosed = true;
-    } else if (ch === "," && top) {
-      top.complete++;
-      top.childClosed = false;
-      top.expectKey = top.kind === "object";
-    }
-  }
-  return stack;
-}
-function sliceSummaryLine(shown, details) {
-  if (!shown.startsWith("{") && !shown.startsWith("[")) return "";
-  const stack = openContainersAt(shown, details);
-  const root = stack.at(0);
-  const deepest = stack.at(-1);
-  if (!root || !deepest) return "";
-  const summary = {
-    // Between two children the cut is named by their container.
-    cutAt: deepest.childClosed || deepest.expectKey ? deepest.path : childPath(deepest),
-    droppedKeys: [],
-    keptItems: {}
+    if (!isRecord5(input)) {
+      const text = serializeResult(input);
+      if (text.length <= budget) return text;
+      if (typeof input === "string" && budget > 2) {
+        const kept = largestFitting(Math.min(input.length, budget - 2), (length) => serializeResult(truncateUtf16(input, length)).length <= budget);
+        const prefix = truncateUtf16(input, kept);
+        if (prefix.length > 0 && record2(summary.slicedKeys ??= {}, path9 || "(root)", { keptChars: prefix.length, totalChars: input.length })) return serializeResult(prefix);
+      }
+      omit(path9 || "(root)");
+      return void 0;
+    }
+    const fields = Object.entries(input).filter(([key]) => !key.startsWith("__"));
+    const priority = ([key, child]) => key === "queryPage" && isRecord5(child) ? 0 : typeof child === "string" && child.length > budget ? 2 : Number(typeof child === "object" && child !== null);
+    fields.sort((a, b) => priority(a) - priority(b));
+    const shown2 = [];
+    let used = 2;
+    for (const [key, child] of fields) {
+      const childPath = path9 ? `${path9}.${key}` : key;
+      const prefix = `${JSON.stringify(key)}:`;
+      const allowance = budget - used - prefix.length - (shown2.length > 0 ? 1 : 0);
+      if (allowance < 2) {
+        omit(childPath);
+        continue;
+      }
+      const text = project(child, allowance, childPath, input, path9);
+      if (text === void 0) continue;
+      shown2.push(prefix + text);
+      used += prefix.length + text.length + (shown2.length > 1 ? 1 : 0);
+    }
+    return `{${shown2.join(",")}}`;
   };
-  for (const container of stack.slice(0, MAX_SUMMARY_DEPTH)) {
-    const total = container.kind === "array" ? Array.isArray(container.value) ? container.value.length : void 0 : serializedKeys(container.value)?.length;
-    if (total === void 0) break;
-    if (container === root && container.kind === "object") continue;
-    const shownCount = container.complete + (container.childClosed ? 1 : 0);
-    summary.keptItems[container.path || "(root)"] = container.kind === "array" ? `${shownCount} of ${total}` : `${shownCount} of ${total} keys`;
-  }
-  const rootKeys = root.kind === "object" ? serializedKeys(root.value) : void 0;
-  if (rootKeys) {
-    const inProgress = root.expectKey || root.childClosed ? 0 : 1;
-    const dropped = rootKeys.slice(root.complete + (root.childClosed ? 1 : 0) + inProgress);
-    const record2 = root.value;
-    for (const key of dropped.slice(0, MAX_SUMMARY_KEYS)) {
-      const label = shortSegment(key);
-      summary.droppedKeys.push(label);
-      const value = record2[key];
-      if (Array.isArray(value)) summary.keptItems[label] = `0 of ${value.length}`;
-    }
-    if (dropped.length > MAX_SUMMARY_KEYS) summary.moreDroppedKeys = dropped.length - MAX_SUMMARY_KEYS;
-  }
-  return `${TRUNCATION_SUMMARY_KEY}: ${JSON.stringify(summary)}`;
-}
-function markedSlice(full, details) {
-  let cut = MAX_TOOL_RESULT_CHARS;
-  for (let attempt = 0; attempt < 4; attempt++) {
-    const line = sliceSummaryLine(full.slice(0, cut), details);
-    const cost = line ? line.length + 1 : 0;
-    if (cut + cost <= MAX_TOOL_RESULT_CHARS) {
-      return full.slice(0, cut) + "\n" + (line ? line + "\n" : "") + TRUNCATION_NOTE;
-    }
-    cut = MAX_TOOL_RESULT_CHARS - cost - attempt * 16;
-  }
-  return full.slice(0, MAX_TOOL_RESULT_CHARS) + "\n" + TRUNCATION_NOTE;
+  const projected = project(value, MAX_TOOL_RESULT_CHARS - PROJECTION_SUMMARY_CHARS, "");
+  const shown = projected === void 0 ? {} : JSON.parse(projected);
+  const output = isRecord5(shown) ? shown : { items: shown };
+  return serializeResult({ ...output, __truncated: true, [TRUNCATION_SUMMARY_KEY]: summary });
 }
 function truncateToolResult(details) {
   const annotated = withPartialLists(details);
   const full = serializeResult(annotated);
   if (full.length <= MAX_TOOL_RESULT_CHARS) return full;
-  if (full.length > MAX_STRUCTURED_TRUNCATION_CHARS) return markedSlice(full, annotated);
+  if (full.length > MAX_STRUCTURED_TRUNCATION_CHARS) return boundedProjection(full);
   if (Array.isArray(details)) {
     const render2 = (rows) => serializeResult({
       items: rows,
@@ -16801,7 +16854,7 @@ function truncateToolResult(details) {
   if (details && typeof details === "object") {
     const obj = details;
     const arrayKey = largestArrayKey(obj);
-    if (!arrayKey) return trimNestedArrays(full) ?? markedSlice(full, annotated);
+    if (!arrayKey) return trimNestedArrays(full) ?? boundedProjection(full);
     const rows = obj[arrayKey];
     const render2 = (kept) => {
       const cursors = {};
@@ -16819,7 +16872,7 @@ function truncateToolResult(details) {
     if (fitsCap(out) && (nested === void 0 || keptRowTotal(nested) <= keptRowTotal(out))) return out;
     if (nested !== void 0) return nested;
   }
-  return markedSlice(full, annotated);
+  return boundedProjection(full);
 }
 function textResult2(details, responseSchemas = []) {
   const components = responseSchemas.length > 0 ? responseComponents() : {};
@@ -16829,6 +16882,40 @@ function textResult2(details, responseSchemas = []) {
     details
   };
 }
+var MEMO_STORED_READS = /* @__PURE__ */ new Set([
+  CanonryMcpToolNames.canonry_competitor_landscape,
+  CanonryMcpToolNames.canonry_measurement_overview,
+  CanonryMcpToolNames.canonry_measurement_portfolio_summary,
+  CanonryMcpToolNames.canonry_measurement_property_evidence,
+  CanonryMcpToolNames.canonry_measurement_property_questions,
+  CanonryMcpToolNames.canonry_measurement_question_result,
+  CanonryMcpToolNames.canonry_measurement_property_competitors,
+  CanonryMcpToolNames.canonry_measurement_changes,
+  CanonryMcpToolNames.canonry_visibility_report,
+  CanonryMcpToolNames.canonry_visibility_stats,
+  CanonryMcpToolNames.canonry_visibility_compare,
+  CanonryMcpToolNames.canonry_sentiment,
+  CanonryMcpToolNames.canonry_sentiment_settings,
+  CanonryMcpToolNames.canonry_sentiment_evidence,
+  CanonryMcpToolNames.canonry_sentiment_compare,
+  CanonryMcpToolNames.canonry_sentiment_backfill_preview,
+  CanonryMcpToolNames.canonry_insights_list
+]);
+var STORED_PAGE_READS = /* @__PURE__ */ new Set([
+  ...MEMO_STORED_READS,
+  CanonryMcpToolNames.canonry_project_overview,
+  CanonryMcpToolNames.canonry_measurement_data_quality,
+  CanonryMcpToolNames.canonry_sentiment_job,
+  CanonryMcpToolNames.canonry_sentiment_jobs
+]);
+var storedReadTools = /* @__PURE__ */ new WeakSet();
+var storedPageReadTools = /* @__PURE__ */ new WeakSet();
+function isStoredReadTool(tool) {
+  return storedReadTools.has(tool);
+}
+function isStoredPageReadTool(tool) {
+  return storedPageReadTools.has(tool);
+}
 function stripProjectFromJsonSchema(jsonSchema) {
   if (!jsonSchema || typeof jsonSchema !== "object") {
     return { schema: jsonSchema, hadProject: false };
@@ -16857,17 +16944,20 @@ function mcpToAgentTool(tool, ctx) {
     const result2 = await runWithUsageTags(ctx.client, { mcpTool: tool.name, mcpCall: randomUUID2() }, () => tool.handler(ctx.client, handlerInput));
     return textResult2(result2, responseSchemas);
   };
-  return {
+  const adapted = {
     name: tool.name,
     label: tool.title,
     description: tool.description,
     parameters,
     execute
   };
+  if (tool.access === "read" && MEMO_STORED_READS.has(tool.name)) storedReadTools.add(adapted);
+  if (tool.access === "read" && STORED_PAGE_READS.has(tool.name)) storedPageReadTools.add(adapted);
+  return adapted;
 }
 var AERO_EXCLUDED_MCP_TOOLS = /* @__PURE__ */ new Set([
-  // Aero reads stored sentiment. Turning it on and submitting a backfill start
-  // paid classifier work, so they stay with the operator (API, CLI, external MCP).
+  // Aero reads stored sentiment. Configuration and backfill submission can
+  // start paid classifier work and remain operator actions.
   "canonry_sentiment_configure",
   "canonry_sentiment_backfill",
   CanonryMcpToolNames.canonry_agent_clear,
@@ -17281,6 +17371,8 @@ function splitAeroAnthropicSystemCachePayload(payload, model) {
 
 // src/agent/runtime.ts
 import { z } from "zod";
+import { randomUUID as randomUUID3 } from "crypto";
+import { isDeepStrictEqual } from "util";
 import {
   Type as Type4,
   createInitialSystemMessage,
@@ -17291,14 +17383,156 @@ var DISCOVER = "aero_list_toolkits";
 var MAX_VISIBLE_TOOLS = 128;
 var LOAD = "aero_load_toolkit";
 var metadata = new Map(canonryMcpTools.map((tool) => [tool.name, tool]));
+var PAGE_REFERENCE_PREFIX = "aero-page:";
+var PAGE_SIZE_PARAMS = /* @__PURE__ */ new Set(["limit", "queryLimit", "attemptLimit"]);
+var PAGE_CURSORS = [
+  { owner: [], key: "nextCursor", parameter: "cursor" },
+  { owner: ["properties"], key: "nextCursor", parameter: "cursor" },
+  { owner: ["queryPage"], key: "nextCursor", parameter: "queryCursor" },
+  { owner: [], key: "nextAttemptCursor", parameter: "attemptCursor" }
+];
 var runtimes = /* @__PURE__ */ new WeakMap();
 var TOOL_LIMIT_WRAP_UP = "This turn has used its tool budget, and no tools are available now. Answer the question from the tool results above: give what they establish with their numbers, say plainly which parts you could not check, and suggest one narrower question the user could ask next.";
+var TIME_LIMIT_WRAP_UP = TOOL_LIMIT_WRAP_UP.replace("used its tool budget", "used its research time budget");
 function result(value) {
   return { content: [{ type: "text", text: truncateToolResult(value) }], details: value };
 }
+function pageDefaults(tool, params) {
+  const filled = { ...params };
+  for (const [key, property] of Object.entries(pageOwner(tool.parameters, ["properties"]) ?? {})) {
+    const schema = pageOwner(property, []);
+    if (filled[key] === void 0 && schema && Object.hasOwn(schema, "default")) filled[key] = structuredClone(schema.default);
+  }
+  return filled;
+}
+function pageSelection(tool, params, parameter) {
+  const selection = pageDefaults(tool, params);
+  if (tool.name === CanonryMcpToolNames.canonry_measurement_portfolio_summary && selection.list === void 0) {
+    selection.list = MeasurementPortfolioLists["weakest-properties"];
+  }
+  return Object.fromEntries(Object.entries(selection).filter(([key, value]) => key !== parameter && !PAGE_SIZE_PARAMS.has(key) && value !== void 0));
+}
+function inheritPageArguments(runtime, message, visible) {
+  for (const block of message.content) {
+    if (block.type !== "toolCall" || !visible.has(block.name)) continue;
+    const tool = runtime.allowed.find((candidate) => candidate.name === block.name);
+    if (!tool || !isStoredPageReadTool(tool) || !pageOwner(block.arguments, [])) continue;
+    let params = block.arguments;
+    for (const parameter of new Set(PAGE_CURSORS.map((cursor) => cursor.parameter))) {
+      const reference = params[parameter];
+      const page = typeof reference === "string" ? runtime.pageReferences.get(reference) : void 0;
+      if (page?.tool === tool && page.parameter === parameter) params = { ...page.params, ...params };
+    }
+    block.arguments = pageDefaults(tool, params);
+  }
+}
+function resolvePageReferences(runtime, tool, params) {
+  if (params === null || typeof params !== "object" || Array.isArray(params)) return params;
+  let resolved = params;
+  for (const parameter of new Set(PAGE_CURSORS.map((cursor) => cursor.parameter))) {
+    const value = resolved[parameter];
+    if (typeof value !== "string" || !value.startsWith(PAGE_REFERENCE_PREFIX)) continue;
+    const page = runtime.pageReferences.get(value);
+    if (!page) throw new Error("This Aero page reference is no longer available. Read the first page again with the original filters.");
+    const inherited = { ...page.params, ...resolved };
+    if (page.tool !== tool || page.parameter !== parameter || !isDeepStrictEqual(page.selection, pageSelection(tool, inherited, parameter))) {
+      throw new Error("Use this Aero page reference with the same tool and original filters; only limit, queryLimit or attemptLimit may change.");
+    }
+    resolved = { ...inherited, [parameter]: page.token };
+  }
+  return resolved;
+}
+function pageOwner(value, path9) {
+  let owner = value;
+  for (const key of path9) {
+    if (owner === null || typeof owner !== "object" || Array.isArray(owner)) return void 0;
+    owner = owner[key];
+  }
+  return owner !== null && typeof owner === "object" && !Array.isArray(owner) ? owner : void 0;
+}
+function referencePages(runtime, tool, params, value) {
+  if (!isStoredPageReadTool(tool) || value.isError || value.content.length !== 1 || params === null || typeof params !== "object" || Array.isArray(params)) return value;
+  const block = value.content[0];
+  if (block.type !== "text") return value;
+  let shown;
+  try {
+    shown = JSON.parse(block.text);
+  } catch {
+    return value;
+  }
+  const root = pageOwner(shown, []);
+  if (!root || root.__truncated === true) return value;
+  let changed = false;
+  for (const cursor of PAGE_CURSORS) {
+    const owner = pageOwner(root, cursor.owner);
+    const token = owner?.[cursor.key];
+    if (!Object.hasOwn(pageOwner(tool.parameters, ["properties"]) ?? {}, cursor.parameter) || !owner || owner.__truncated === true || typeof token !== "string" || token !== pageOwner(value.details, cursor.owner)?.[cursor.key]) continue;
+    if (runtime.pageReferences.size >= runtime.limits.maxToolCalls * PAGE_CURSORS.length) break;
+    const reference = `${PAGE_REFERENCE_PREFIX}${runtime.pageNamespace}-${runtime.pageTurn}:${runtime.pageReferences.size + 1}`;
+    if (token.length <= reference.length) continue;
+    runtime.pageReferences.set(reference, {
+      tool,
+      token,
+      parameter: cursor.parameter,
+      params: structuredClone(params),
+      selection: structuredClone(pageSelection(tool, params, cursor.parameter))
+    });
+    owner[cursor.key] = reference;
+    const pagination = pageOwner(root.__pagination, []);
+    for (const [path9, note] of Object.entries(pagination ?? {})) {
+      if (typeof note === "string") pagination[path9] = note.split(token).join(reference);
+    }
+    changed = true;
+  }
+  if (!changed) return value;
+  root.__pageReferences = "Aero page references expire at the end of this turn. Pass them unchanged to the same tool. Omitted filters inherit the original scope; supplied filters must match. Only the page size may change.";
+  let text = JSON.stringify(root);
+  if (text.length > block.text.length) {
+    delete root.__pageReferences;
+    text = JSON.stringify(root);
+  }
+  return { ...value, content: [{ ...block, text }] };
+}
 function visibleTools(runtime) {
-  if (!runtime.progressive) return runtime.allowed;
-  const visible = runtime.allowed.filter((tool) => {
+  const allowed = runtime.allowed.map((tool) => ({
+    ...tool,
+    execute: async (id, params, signal, onUpdate) => {
+      const dispatchedParams = resolvePageReferences(runtime, tool, params);
+      const safeRead = isStoredReadTool(tool);
+      const key = safeRead ? `${tool.name}:${JSON.stringify(dispatchedParams)}` : void 0;
+      const prior = key === void 0 ? void 0 : runtime.memo.get(key);
+      if (prior) {
+        const previous = await prior.value;
+        if (!previous.isError) return result({ alreadyReturned: true, toolCallId: prior.id, note: "Already returned above. Use that result and follow its pagination instruction. A cap-cut page must be re-requested from the original cursor with a smaller limit." });
+      }
+      if (!safeRead) runtime.memo.clear();
+      const research = runtime.research?.signal;
+      const signals = [signal, research].filter((value) => value !== void 0);
+      const combined = signals.length > 0 ? AbortSignal.any(signals) : void 0;
+      let interrupted;
+      const work = Promise.race([
+        tool.execute(id, dispatchedParams, combined, onUpdate),
+        new Promise((_resolve, reject) => {
+          interrupted = () => reject(new Error("Research time budget elapsed; dispatched work may still settle."));
+          research?.addEventListener("abort", interrupted, { once: true });
+          if (research?.aborted) interrupted();
+        })
+      ]).then((value) => referencePages(runtime, tool, dispatchedParams, value)).finally(() => {
+        if (interrupted) research?.removeEventListener("abort", interrupted);
+      });
+      if (key !== void 0) runtime.memo.set(key, { id, value: work });
+      try {
+        const value = await work;
+        if (key !== void 0 && value.isError) runtime.memo.delete(key);
+        return value;
+      } catch (error) {
+        if (key !== void 0) runtime.memo.delete(key);
+        throw error;
+      }
+    }
+  }));
+  if (!runtime.progressive) return allowed;
+  const visible = allowed.filter((tool) => {
     const entry = metadata.get(tool.name);
     return !entry || entry.tier === "core" || runtime.pinned.has(tool.name) || runtime.loaded.has(entry.tier);
   });
@@ -17379,11 +17613,26 @@ function correctToolNames(runtime, message, visible) {
     block.name = matches[0];
   }
 }
-function withCorrectedToolNames(runtime, response, visible) {
+function withCorrectedToolNames(runtime, response, visible, wrapUp, signal) {
   const result2 = response.result.bind(response);
   response.result = async () => {
     const message = await result2();
+    const researchEnded = !wrapUp && runtime.research?.signal.aborted && !signal?.aborted;
+    const canFinish = wrapUp && (!signal?.aborted || runtime.hardDeadline);
+    const failedAnswer = canFinish && !runtime.hardDeadline && (message.stopReason === "error" || message.stopReason === "aborted");
+    if (researchEnded) {
+      message.content = message.content.filter((block) => block.type !== "toolCall");
+      if (!message.content.some((block) => block.type === "text" && block.text.trim())) message.content.push({ type: "text", text: "Research time budget elapsed; preparing an answer from the evidence already gathered." });
+      message.stopReason = "stop";
+      delete message.errorMessage;
+    } else if (canFinish && (message.stopReason === "error" || message.stopReason === "aborted" || !message.content.some((block) => block.type === "text" && block.text.trim()))) {
+      message.content.push({ type: "text", text: `I reached this turn's ${runtime.reason === "time-limit" ? "time" : "tool"} limit and could not complete the answer. The results above are partial; ask a narrower question to continue.` });
+      message.stopReason = "stop";
+      delete message.errorMessage;
+    }
+    if (failedAnswer) runtime.reason = "error";
     correctToolNames(runtime, message, visible);
+    inheritPageArguments(runtime, message, visible);
     return message;
   };
   return response;
@@ -17417,7 +17666,7 @@ function explainMissingTool(runtime, message) {
 function configureAeroRuntime(agent, allowed, limits, progressive = true, pinned = []) {
   let runtime = runtimes.get(agent);
   if (!runtime) {
-    runtime = { allowed, loaded: /* @__PURE__ */ new Set(), limits: agentTurnLimitsSchema.parse(limits ?? {}), calls: 0, rounds: 0, startedAt: 0, reason: "completed", progressive, pinned: new Set(pinned), corrected: /* @__PURE__ */ new Map(), wrapUp: false };
+    runtime = { allowed, loaded: /* @__PURE__ */ new Set(), limits: agentTurnLimitsSchema.parse(limits ?? {}), calls: 0, rounds: 0, startedAt: 0, reason: "completed", progressive, pinned: new Set(pinned), corrected: /* @__PURE__ */ new Map(), wrapUp: false, hardDeadline: false, memo: /* @__PURE__ */ new Map(), pageReferences: /* @__PURE__ */ new Map(), pageNamespace: randomUUID3().slice(0, 8), pageTurn: 0 };
     runtimes.set(agent, runtime);
     const state = runtime;
     const stream = agent.streamFunction;
@@ -17425,29 +17674,39 @@ function configureAeroRuntime(agent, allowed, limits, progressive = true, pinned
       options?.signal?.throwIfAborted();
       state.rounds++;
       const visible = new Set(getCurrentTools(context.messages).map((tool) => tool.name));
-      const response = stream(model, context, options);
-      return response instanceof Promise ? response.then((ready) => withCorrectedToolNames(state, ready, visible)) : withCorrectedToolNames(state, response, visible);
+      const wrapUp = state.wrapUp;
+      const signals = [options?.signal, wrapUp ? void 0 : state.research?.signal].filter((value) => value !== void 0);
+      const messages = [...context.messages];
+      let clockIndex = 0;
+      while (messages[clockIndex]?.role === "system") clockIndex++;
+      messages.splice(clockIndex, 0, {
+        role: "system",
+        timestamp: state.startedAt,
+        content: `Current turn clock (UTC): ${new Date(state.startedAt).toISOString()}. Use this current UTC date and year for relative dates or omitted years unless the user explicitly specifies a year. Stored run and scan dates remain authoritative; this clock is not an observation date.`
+      });
+      const response = stream(model, { ...context, messages }, { ...options, ...signals.length > 0 ? { signal: AbortSignal.any(signals) } : {} });
+      return response instanceof Promise ? response.then((ready) => withCorrectedToolNames(state, ready, visible, wrapUp, options?.signal)) : withCorrectedToolNames(state, response, visible, wrapUp, options?.signal);
     };
     const before = agent.beforeToolCall;
     const after = agent.afterToolCall;
     const overLimit = /* @__PURE__ */ new Set();
     agent.beforeToolCall = async (event, signal) => {
-      if (signal?.aborted || overLimit.has(event.toolCall.id)) return { block: true, reason: "Turn stopped." };
+      if (signal?.aborted || state.reason === "time-limit" || state.wrapUp || overLimit.has(event.toolCall.id)) return { block: true, reason: "Turn stopped." };
       return before?.(event, signal);
     };
     const finish = agent.finishTurn;
     agent.finishTurn = (turn, signal) => {
-      if (state.reason !== "tool-limit") return finish?.(turn, signal);
+      if (state.reason !== "tool-limit" && state.reason !== "time-limit") return finish?.(turn, signal);
       if (state.wrapUp) return { action: "end" };
       state.wrapUp = true;
       return { action: "continue" };
     };
     const prepare = agent.prepareNextTurnWithContext;
     agent.prepareNextTurnWithContext = (turn, signal) => {
-      if (state.reason === "tool-limit" && state.wrapUp) {
+      if ((state.reason === "tool-limit" || state.reason === "time-limit") && state.wrapUp) {
         return {
           context: { ...turn.context, tools: [] },
-          messages: [{ role: "system", content: TOOL_LIMIT_WRAP_UP, timestamp: Date.now() }]
+          messages: [{ role: "system", content: state.reason === "time-limit" ? TIME_LIMIT_WRAP_UP : TOOL_LIMIT_WRAP_UP, timestamp: Date.now() }]
         };
       }
       return prepare ? prepare(turn, signal) : agent.prepareNextTurn?.(signal);
@@ -17466,7 +17725,7 @@ function configureAeroRuntime(agent, allowed, limits, progressive = true, pinned
     agent.subscribe((event) => {
       if (event.type === "tool_execution_start") {
         if (state.calls >= state.limits.maxToolCalls) {
-          state.reason = "tool-limit";
+          if (state.reason !== "time-limit") state.reason = "tool-limit";
           overLimit.add(event.toolCallId);
         } else if (!agent.signal?.aborted) {
           state.calls++;
@@ -17497,24 +17756,41 @@ function configureAeroRuntime(agent, allowed, limits, progressive = true, pinned
         overLimit.clear();
         state.corrected.clear();
         state.wrapUp = false;
+        state.hardDeadline = false;
+        state.memo.clear();
+        state.pageReferences.clear();
+        state.pageTurn++;
+        state.research = new AbortController();
         state.calls = 0;
         state.rounds = 0;
         state.reason = "completed";
         state.startedAt = Date.now();
         state.finishedAt = void 0;
+        const reservedMs = Math.min(15e3, Math.max(250, Math.floor(state.limits.timeoutMs / 10)));
         state.timer = setTimeout(() => {
+          if (state.wrapUp) return;
+          state.reason = "time-limit";
+          state.research?.abort();
+        }, state.limits.timeoutMs - reservedMs);
+        state.deadlineTimer = setTimeout(() => {
           state.reason = "time-limit";
+          state.hardDeadline = true;
           agent.abort();
         }, state.limits.timeoutMs);
         state.timer.unref();
+        state.deadlineTimer.unref();
       } else if (event.type === "agent_end") {
         state.finishedAt = Date.now();
         clearTimeout(state.timer);
-        if ((state.reason === "completed" || state.reason === "tool-limit") && agent.signal?.aborted) state.reason = "stopped";
-        if ((state.reason === "completed" || state.reason === "tool-limit") && agent.state.errorMessage) state.reason = "error";
+        clearTimeout(state.deadlineTimer);
+        state.memo.clear();
+        state.pageReferences.clear();
+        if (agent.signal?.aborted && !state.hardDeadline) state.reason = "stopped";
+        if (state.reason === "completed" && agent.state.errorMessage) state.reason = "error";
       }
     });
   }
+  runtime.pageReferences.clear();
   runtime.allowed = allowed;
   runtime.loaded = /* @__PURE__ */ new Set();
   runtime.limits = agentTurnLimitsSchema.parse(limits ?? {});
@@ -17823,11 +18099,6 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 var log21 = createLogger("RemoteMcp");
 var AERO_EXCLUDED_MCP_TOOLS2 = /* @__PURE__ */ new Set([]);
-var MAX_TOOL_RESULT_CHARS2 = 2e4;
-function truncate(text) {
-  if (text.length <= MAX_TOOL_RESULT_CHARS2) return text;
-  return text.slice(0, MAX_TOOL_RESULT_CHARS2) + "\n... (truncated, result too large)";
-}
 async function connectStreamableHttp(server) {
   const transport = new StreamableHTTPClientTransport(new URL(server.url), {
     requestInit: {
@@ -17853,8 +18124,23 @@ function adaptRemoteTool(client, tool) {
   );
   const execute = async (_toolCallId, params) => {
     const result2 = await client.callTool({ name: tool.name, arguments: params });
+    let shown = result2;
+    if (result2 && typeof result2 === "object") {
+      const envelope = result2;
+      if (envelope.structuredContent !== void 0) shown = envelope.structuredContent;
+      else if (envelope.content?.length === 1 && envelope.content[0]?.type === "text") {
+        const text = envelope.content[0].text ?? "";
+        try {
+          shown = JSON.parse(text);
+        } catch {
+          shown = text;
+        }
+      } else if (envelope.content?.some((block) => block.type === "text")) {
+        shown = { ...result2, content: Object.fromEntries(envelope.content.map((block, index) => [`block_${index + 1}`, block])) };
+      }
+    }
     return {
-      content: [{ type: "text", text: truncate(JSON.stringify(result2, null, 2)) }],
+      content: [{ type: "text", text: truncateToolResult(shown) }],
       details: result2,
       isError: isRemoteToolError(result2)
     };
@@ -18027,10 +18313,10 @@ var ADVANCED_TOOLS = [
 var LEGACY_TOOLS = ["canonry_measurement_overview", "canonry_measurement_plan_get", "canonry_run_completeness"];
 var SIMPLE_TOOLS = ["canonry_visibility_report"];
 var ADVANCED_ROUTES = [
-  "Weakest or strongest Properties: canonry_measurement_portfolio_summary (rows with metro, names written instead and cited domains; mentionRanking for both ends). For more rows pass groupKey, or page canonry_measurement_overview.",
-  "Which metros have the biggest gaps: the summary's markets (every metro) and tiedAtWeakest.byMetro.",
+  "Weakest or strongest Properties: canonry_measurement_portfolio_summary (mentionRanking for both ends). Compact results carry detailsOmitted; use Property evidence reads for omitted names and cited domains. The default cursor enumerates weakest Properties only; set list=strongest-mentions or list=weakest-mentions to enumerate the chosen ranking. Follow nextCursor with unchanged list and filters; pageList names that selection. Use groupKey or page canonry_measurement_overview for all Property rows.",
+  "Which metros have the biggest gaps: the compact summary's weakestMarkets, whose rates cover full top-level metros. Set list=markets and follow nextCursor with unchanged list and filters for every market; tiedAtWeakest describes only the zero-signal Property cohort, never full metro rates.",
   "One Property: canonry_measurement_property_evidence and canonry_measurement_property_competitors (names written instead of it, and citedDomains, its own cited sources). Portfolio lists such as weakestAnswerSources pool many Properties.",
-  'Which names answers give instead across the portfolio: canonry_competitor_landscape with queryClass and runId "latest". Per-Property named-instead lists are samples of weak Properties.',
+  'Which names answers give instead across the portfolio: canonry_competitor_landscape with queryClass and runId "latest", answers=not-mentioned. This selects answers naming none of their targeted Properties; preserve populationSize, answerCount and unknownMentionAnswers. Per-Property named-instead lists are samples of weak Properties.',
   'Where answers get their sources: canonry_analytics_sources with queryClass and runId "latest"; without them it pools both classes and every sweep.',
   "What changed since the last sweep: canonry_measurement_changes once per class. Quote its distribution for how many Properties moved.",
   "Is the sweep complete, or is anything unreliable: canonry_measurement_data_quality (quote completeness expected, executed and missing, unattributedByClass and latestFill), then canonry_run_completeness with its run.displayedRunId for missing answers per engine. A Healthy run status and canonry_doctor are not completeness checks."
@@ -18060,7 +18346,7 @@ Project shape: an Advanced Measurement plan on the legacy schema v1 (plan revisi
         prompt: `
 
 Project shape: an Advanced Measurement portfolio (plan revision ${version.revision}) with ${size}, ${queriesIn("branded")} branded and ${queriesIn("non-brand")} non-brand queries. This line settles the project type.
-Rules: measure per Property, group or market, never pool branded and non-brand, and a query shared by several Properties is one answer scored for each. Denominators count answers (queries x engines), not queries; label them answers. Group Properties only by the metro and submarkets the tools return, never by name. Names given instead were written in the answer text, not cited; cited domains are sources and never go under a named-instead heading. Name only engines a tool returned. Between two sweeps, a Property that moved ${MEASUREMENT_CHANGES_NOISE_ANSWERS} answers or fewer is within noise (withinNoise): never call it a gain, loss, trend or regression. Judge mention and citation separately (mentionWithinNoise, citationWithinNoise): a signal that moved ${MEASUREMENT_CHANGES_NOISE_ANSWERS} answers or fewer is within noise even when the Property's other signal moved more. Quote every coverage figure with its counts, headline and branded figures included; the value text carries them, as in 25.0% (6/24). A Property's citation coverage counts only citations of its own page: 0% does not mean your domain went uncited (weakestAnswerSources.ownDomainAnswers counts that). Property names often carry the brand, so that most listed Properties carry it is not a finding. Properties tied at the weakest rate are not ranked: they are listed by name, so say how many tie (tiedAtWeakest.count), give tiedAtWeakest.byMetro, and call the listed rows examples of the tie, not a ranked bottom list. A result with truncated true, a total above its rows, __partialLists or __truncation is partial: say how many of how many you saw, and never call those rows the biggest, all, or the full picture.
+Rules: measure per Property, group or market, never pool branded and non-brand, and a query shared by several Properties is one answer scored for each. Denominators count answers (queries x engines), not queries; label them answers. Group Properties only by the metro and submarkets the tools return, never by name. Names given instead were written in the answer text, not cited; cited domains are sources and never go under a named-instead heading. Name only engines a tool returned. Between two sweeps, a Property that moved ${MEASUREMENT_CHANGES_NOISE_ANSWERS} answers or fewer is within noise (withinNoise): never call it a gain, loss, trend or regression. Judge mention and citation separately (mentionWithinNoise, citationWithinNoise): a signal that moved ${MEASUREMENT_CHANGES_NOISE_ANSWERS} answers or fewer is within noise even when the Property's other signal moved more. Quote every coverage figure with its counts, headline and branded figures included; the value text carries them, as in 25.0% (6/24). A Property's citation coverage counts only citations of its own page: 0% does not mean your domain went uncited (weakestAnswerSources.ownDomainAnswers counts that). Property names often carry the brand, so that most listed Properties carry it is not a finding. tiedAtWeakest counts Properties with zero mentions and zero citations, separate from propertiesNeverMentioned (which may include cited Properties). Say how many tie (tiedAtWeakest.count); compact results omit the cohort's byMetro details. Call listed tie rows examples, not a ranked bottom list. A result with truncated true, a total above its rows, __partialLists or __truncation is partial: say how many of how many you saw, and never call those rows the biggest, all, or the full picture.
 Route each question to its read:
 ${ADVANCED_ROUTES.map((route) => `- ${route}`).join("\n")}
 canonry_visibility_report describes the whole project, not one Property. canonry_measurement_plan_get is plan structure with no metrics; do not read it for analysis.`,
@@ -21039,7 +21325,7 @@ function cloneGtmConfig(config) {
 function createGoogleMarketingConfigCredentialStore(input) {
   const persistConfigPatch = input.saveConfigPatch ?? saveConfigPatch;
   const env = input.env ?? process.env;
-  const randomUUID3 = input.randomUUID ?? crypto29.randomUUID;
+  const randomUUID4 = input.randomUUID ?? crypto29.randomUUID;
   const snapshot = () => ({
     googleAds: cloneGoogleAdsConfig(input.config.googleAds),
     gtm: cloneGtmConfig(input.config.gtm)
@@ -21087,7 +21373,7 @@ function createGoogleMarketingConfigCredentialStore(input) {
           upsertGoogleAdsConnection(input.config, {
             projectId: project.id,
             projectName: project.name,
-            credentialGeneration: randomUUID3(),
+            credentialGeneration: randomUUID4(),
             ...credential.accessToken ? { accessToken: credential.accessToken } : {},
             refreshToken: credential.refreshToken ?? null,
             tokenExpiresAt: credential.expiresAt ?? null,
@@ -21099,7 +21385,7 @@ function createGoogleMarketingConfigCredentialStore(input) {
           upsertGtmConnection(input.config, {
             projectId: project.id,
             projectName: project.name,
-            credentialGeneration: randomUUID3(),
+            credentialGeneration: randomUUID4(),
             ...credential.accessToken ? { accessToken: credential.accessToken } : {},
             refreshToken: credential.refreshToken ?? null,
             tokenExpiresAt: credential.expiresAt ?? null,