@agentcentral/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -17,7 +17,7 @@ var CliError = class extends Error {
 };
 
 // src/constants.ts
-var CLI_VERSION = "0.1.1";
+var CLI_VERSION = "0.1.2";
 var DEFAULT_MCP_ENDPOINT = "https://mcp.agentcentral.to/mcp";
 var ENV_API_KEY = "AGENT_CENTRAL_API_KEY";
 var ENV_API_KEY_LEGACY = "AGENTCENTRAL_API_KEY";
@@ -34,13 +34,14 @@ var API_KEY_PREFIX = "ac_live_";
 
 // src/config.ts
 import {
-  chmodSync,
   closeSync,
   existsSync,
   fstatSync,
   mkdirSync,
   openSync,
   readFileSync,
+  renameSync,
+  unlinkSync,
   writeFileSync
 } from "fs";
 import { homedir } from "os";
@@ -107,9 +108,23 @@ function loadConfig(env = process.env) {
 function saveConfig(config, env = process.env) {
   const path = configPath(env);
   const dir = dirname(path);
+  const tmp = `${path}.${process.pid}.tmp`;
   mkdirSync(dir, { recursive: true, mode: 448 });
-  writeFileSync(path, JSON.stringify(config, null, 2), { mode: 384 });
-  chmodSync(path, 384);
+  const data = JSON.stringify(config, null, 2);
+  try {
+    writeFileSync(tmp, data, { mode: 384, flag: "wx" });
+    renameSync(tmp, path);
+  } catch (error) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw new CliError(
+      1 /* GeneralFailure */,
+      `failed to write config ${path}`,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
 }
 function upsertProfile(config, profile) {
   const exists = config.profiles.some((p) => p.name === profile.name);
@@ -243,7 +258,128 @@ async function resolveAuth(input) {
   };
 }
 
+// src/exit-codes.ts
+var RPC_INVALID_PARAMS = -32602;
+var DETAIL_MAX_LENGTH = 180;
+var PERMISSION_PATTERN = /no_amazon|not connected|expired|suspended|revoked|past_due|trial expired|permission|not authorized|scope/i;
+var VALIDATION_PATTERN = /invalid|validation|must be|required/i;
+function writeEnvelopeFrom(result) {
+  const structured = result.structuredContent;
+  if (!structured) {
+    return void 0;
+  }
+  const hasWriteShape = "mode" in structured || "status" in structured || "requested_count" in structured;
+  if (!hasWriteShape) {
+    return void 0;
+  }
+  return structured;
+}
+function toolClassification(def) {
+  const hint = def.annotations;
+  const annotationWrite = hint?.destructiveHint === true || hint?.readOnlyHint === false;
+  const properties = def.inputSchema.properties;
+  const props = properties && typeof properties === "object" ? properties : {};
+  const schemaWrite = "confirm" in props && "idempotency_key" in props;
+  const isWrite = annotationWrite || schemaWrite;
+  return {
+    isWrite,
+    supportsPreview: isWrite
+  };
+}
+function classifyToolText(text) {
+  if (PERMISSION_PATTERN.test(text)) {
+    return 4 /* PermissionDenied */;
+  }
+  if (VALIDATION_PATTERN.test(text)) {
+    return 5 /* ValidationFailed */;
+  }
+  return void 0;
+}
+function joinContentText(result) {
+  return result.content.map((block) => typeof block.text === "string" ? block.text : "").filter((text) => text.length > 0).join(" ").trim();
+}
+function truncateDetail(text) {
+  if (text.length <= DETAIL_MAX_LENGTH) {
+    return text;
+  }
+  return `${text.slice(0, DETAIL_MAX_LENGTH)}\u2026`;
+}
+function classifyWriteStatus(status) {
+  switch (status) {
+    case "validation_error":
+      return 5 /* ValidationFailed */;
+    case "partial":
+      return 9 /* PartialWrite */;
+    case "blocked":
+    case "failed":
+      return 7 /* ToolExecutionFailed */;
+    case "duplicate_blocked":
+    case "accepted":
+    case "preview":
+    default:
+      return 0 /* Success */;
+  }
+}
+function summarizeWriteEnvelope(env) {
+  const parts = [];
+  if (typeof env.requested_count === "number") {
+    parts.push(`requested=${env.requested_count}`);
+  }
+  if (typeof env.accepted_count === "number") {
+    parts.push(`accepted=${env.accepted_count}`);
+  }
+  if (typeof env.failed_count === "number") {
+    parts.push(`failed=${env.failed_count}`);
+  }
+  if (typeof env.previewed_count === "number") {
+    parts.push(`previewed=${env.previewed_count}`);
+  }
+  const status = env.status ?? "unknown";
+  return parts.length > 0 ? `${status} (${parts.join(", ")})` : status;
+}
+function classifyResponse(response) {
+  if (response.error) {
+    const message = response.error.message;
+    const code = response.error.code === RPC_INVALID_PARAMS ? 5 /* ValidationFailed */ : classifyToolText(message) ?? 7 /* ToolExecutionFailed */;
+    return {
+      code,
+      status: "rpc_error",
+      detail: message
+    };
+  }
+  const result = response.result;
+  const env = writeEnvelopeFrom(result);
+  if (env?.status) {
+    return {
+      code: classifyWriteStatus(env.status),
+      status: env.status,
+      detail: summarizeWriteEnvelope(env),
+      result
+    };
+  }
+  if (result.isError) {
+    const text = joinContentText(result);
+    const code = classifyToolText(text) ?? 7 /* ToolExecutionFailed */;
+    return {
+      code,
+      status: "tool_error",
+      detail: truncateDetail(text),
+      result
+    };
+  }
+  return {
+    code: 0 /* Success */,
+    status: "ok",
+    detail: truncateDetail(joinContentText(result)),
+    result
+  };
+}
+
 // src/transport.ts
+var RPC_INVALID_PARAMS2 = -32602;
+function classifyRpcError(error) {
+  return error.code === RPC_INVALID_PARAMS2 ? 5 /* ValidationFailed */ : classifyToolText(error.message) ?? 7 /* ToolExecutionFailed */;
+}
 function parseSseJsonRpc(text) {
   const dataLines = text.trim().split(/\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
   return JSON.parse(dataLines.length ? dataLines.join("\n") : text);
@@ -284,115 +420,2776 @@ function buildHeaders(auth, requestId) {
     ...requestId ? { "X-Request-Id": requestId } : {}
   };
 }
-function createClient(auth, opts = {}) {
-  const retry = opts.retry ?? DEFAULT_RETRY;
-  const defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const headers = buildHeaders(auth, opts.requestId);
-  let counter = 0;
-  const nextId = () => {
-    counter += 1;
-    return counter;
-  };
-  async function attempt(method, params, id, timeoutMs) {
-    let res;
-    try {
-      res = await fetch(auth.endpoint, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ jsonrpc: "2.0", id, method, params }),
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-    } catch (error) {
-      if (isAbortError(error)) {
-        throw new CliError(
-          8 /* Timeout */,
-          `Request timed out after ${timeoutMs}ms`,
-          method
-        );
-      }
-      throw new RetryableError(
-        error instanceof Error ? error.message : String(error)
-      );
+function createClient(auth, opts = {}) {
+  const retry = opts.retry ?? DEFAULT_RETRY;
+  const defaultTimeoutMs = opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const headers = buildHeaders(auth, opts.requestId);
+  let counter = 0;
+  const nextId = () => {
+    counter += 1;
+    return counter;
+  };
+  async function attempt(method, params, id, timeoutMs, notification) {
+    const requestBody = notification ? { jsonrpc: "2.0", method, params } : { jsonrpc: "2.0", id, method, params };
+    let res;
+    try {
+      res = await fetch(auth.endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(requestBody),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw new CliError(
+          8 /* Timeout */,
+          `Request timed out after ${timeoutMs}ms`,
+          method
+        );
+      }
+      throw new RetryableError(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    if (res.status === 401) {
+      throw new CliError(
+        3 /* AuthError */,
+        "Authentication failed (HTTP 401): the API key was rejected by the hosted server.",
+        method
+      );
+    }
+    if (res.status === 429 || res.status >= 500) {
+      const retryAfterMs = retry.honorRetryAfter ? parseRetryAfterMs(res.headers.get("retry-after"), Date.now()) : void 0;
+      throw new RetryableError(`HTTP ${res.status}`, {
+        status: res.status,
+        retryAfterMs
+      });
+    }
+    const text = await res.text();
+    if (!res.ok) {
+      throw new CliError(
+        6 /* TransportFailure */,
+        `HTTP ${res.status}: ${text.slice(0, 200)}`,
+        method
+      );
+    }
+    if (notification) {
+      return { jsonrpc: "2.0" };
+    }
+    return parseSseJsonRpc(text);
+  }
+  async function rpc(method, params, rpcOpts) {
+    const timeoutMs = rpcOpts?.timeoutMs ?? defaultTimeoutMs;
+    const notification = rpcOpts?.notification === true;
+    const id = rpcOpts?.id ?? nextId();
+    const maxAttempts = Math.max(1, retry.maxAttempts);
+    let lastReason = "transport failure";
+    for (let n = 1; n <= maxAttempts; n += 1) {
+      try {
+        return await attempt(method, params ?? {}, id, timeoutMs, notification);
+      } catch (error) {
+        if (error instanceof CliError) {
+          throw error;
+        }
+        if (!(error instanceof RetryableError)) {
+          throw error;
+        }
+        lastReason = error.message;
+        if (n >= maxAttempts) break;
+        const backoffMs = retry.baseBackoffMs * 2 ** (n - 1);
+        const delayMs = error.retryAfterMs ?? backoffMs;
+        opts.onRetry?.({ attempt: n, delayMs, reason: lastReason });
+        await sleep(delayMs);
+      }
+    }
+    throw new CliError(
+      6 /* TransportFailure */,
+      `Transport failure after ${maxAttempts} attempt(s): ${lastReason}`,
+      method
+    );
+  }
+  async function listTools(listOpts) {
+    const response = await rpc("tools/list", {}, { timeoutMs: listOpts?.timeoutMs });
+    if (response.error) {
+      throw new CliError(classifyRpcError(response.error), response.error.message, "tools/list");
+    }
+    const result = response.result ?? {};
+    return result.tools ?? [];
+  }
+  async function callTool(name, args, callOpts) {
+    const response = await rpc(
+      "tools/call",
+      { name, arguments: args },
+      { timeoutMs: callOpts?.timeoutMs }
+    );
+    if (response.error) {
+      throw new CliError(classifyRpcError(response.error), response.error.message, name);
+    }
+    return response.result ?? {};
+  }
+  return { rpc, listTools, callTool };
+}
+
+// src/commands/tools.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+
+// ../shared/dist/index.js
+import { z as z2 } from "zod";
+import { z as z22 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+var TABLES = {
+  // Ads API tables
+  campaigns: "amzn_ads_sp_campaigns_v3",
+  campaignSnapshots: "amzn_ads_sp_campaign_snapshots_v1",
+  adsChangeHistory: "amzn_ads_change_history_v1",
+  budgetUsage: "amzn_ads_sp_budget_usage_v1",
+  adgroups: "amzn_ads_sp_campaigns_by_adgroup_v2",
+  placements: "amzn_ads_sp_campaigns_by_placement_v3",
+  advertisedProducts: "amzn_ads_sp_advertised_products_v3",
+  purchasedProducts: "amzn_ads_sp_purchased_products_v3",
+  searchTerms: "amzn_ads_sp_search_terms_v2",
+  targeting: "amzn_ads_sp_targeting_v4",
+  profiles: "amzn_ads_profiles_v2",
+  sqp: "sqp_search_query_by_week",
+  brandMetrics: "amzn_ads_brand_metrics_v1",
+  attributionPerformance: "amzn_ads_attribution_performance_v1",
+  dspPerformance: "amzn_ads_dsp_performance_v1",
+  storeInsights: "amzn_ads_store_insights_v1",
+  sbCampaigns: "amzn_ads_sb_campaigns_v1",
+  sdCampaigns: "amzn_ads_sd_campaigns_v1",
+  sdAdvertisedProducts: "amzn_ads_sd_advertised_products_v1",
+  sdTargeting: "amzn_ads_sd_targeting_v1",
+  agentActions: "agent_actions",
+  writeSubmissions: "write_submissions",
+  // SP-API tables (shared across ads + inventory)
+  salesAndTraffic: "sp_sales_and_traffic_v1",
+  activeListings: "sp_active_listings_v1",
+  suppressedListings: "sp_suppressed_listings_v1",
+  settlements: "sp_settlements_v1",
+  // FBA inventory tables
+  fbaInventory: "sp_fba_inventory_summaries_v1",
+  inventoryHealth: "sp_fba_inventory_health_v1",
+  inventoryLedger: "sp_inventory_ledger_v1",
+  inventoryLedgerSummary: "sp_inventory_ledger_summary_v1",
+  // AWD tables
+  awdInventory: "awd_inventory_v1",
+  awdShipments: "awd_shipments_v1",
+  awdShipmentItems: "awd_shipment_items_v1",
+  // FBA Inbound tables
+  fbaInboundShipments: "sp_fba_inbound_shipments_v1",
+  fbaInboundShipmentItems: "sp_fba_inbound_shipment_items_v1",
+  // SP-API: Orders, returns, reimbursements, financial events, catalog
+  orders: "sp_orders_v1",
+  orderItems: "sp_order_items_v1",
+  returns: "sp_fba_returns_v1",
+  reimbursements: "sp_fba_reimbursements_v1",
+  financialEvents: "sp_financial_events_v1",
+  catalogItems: "sp_catalog_items_v1",
+  listingQuality: "sp_listing_quality_v1",
+  pricingSnapshots: "sp_pricing_v1",
+  replenishmentOffers: "sp_replenishment_offers_v1",
+  customerFeedbackSnapshots: "sp_customer_feedback_snapshots_v1",
+  // SP-API: Fees
+  referralFees: "sp_referral_fees_v1",
+  fbaStorageFeeCharges: "sp_fba_storage_fee_charges_v1",
+  fbaLongTermStorageFeeCharges: "sp_fba_longterm_storage_fee_charges_v1",
+  // Brand Analytics tables
+  baSearchTerms: "ba_search_terms_v1",
+  baMarketBasket: "ba_market_basket_v1",
+  baRepeatPurchase: "ba_repeat_purchase_v1",
+  baSearchCatalog: "ba_search_catalog_v1",
+  // SB (Sponsored Brands) ads tables
+  sbAds: "amzn_ads_sb_ads_v1",
+  sbSearchTerms: "amzn_ads_sb_search_terms_v1",
+  sbTargeting: "amzn_ads_sb_targeting_v1",
+  sbPurchasedProducts: "amzn_ads_sb_purchased_products_v1",
+  sbGrossAndInvalids: "amzn_ads_sb_gross_and_invalids_v1",
+  // SD (Sponsored Display) ads tables
+  sdPurchasedProducts: "amzn_ads_sd_purchased_products_v1",
+  sdGrossAndInvalids: "amzn_ads_sd_gross_and_invalids_v1",
+  // SP (Sponsored Products) gross & invalids
+  spGrossAndInvalids: "amzn_ads_sp_gross_and_invalids_v1",
+  // Infrastructure tables
+  tenants: "tenants",
+  agencies: "agencies",
+  appUsers: "app_users",
+  agencyMemberships: "agency_memberships",
+  tenantMemberships: "tenant_memberships",
+  tenantAdsProfiles: "tenant_ads_profiles",
+  tenantMarketplaceConnections: "tenant_marketplace_connections",
+  apiKeys: "api_keys",
+  apiUsageEvents: "api_usage_events",
+  signupAttribution: "signup_attribution",
+  adLifecycleEvents: "ad_lifecycle_events",
+  adConversionUploads: "ad_conversion_uploads",
+  landingVisits: "landing_visits",
+  alertEvents: "alert_events",
+  remediationActions: "remediation_actions",
+  emailEvents: "email_events",
+  emailVerificationTokens: "email_verification_tokens",
+  passwordResetTokens: "password_reset_tokens",
+  onboardingInvites: "onboarding_invites",
+  tenantDeletionTombstones: "tenant_deletion_tombstones",
+  ingestionMetadata: "sp_ingestion_metadata",
+  asinRegistry: "asin_registry",
+  syncRuns: "sync_runs",
+  syncLeases: "sync_leases",
+  paginationCheckpoints: "pagination_checkpoints",
+  tenantCapabilities: "tenant_capabilities",
+  bqUsageDaily: "bq_usage_daily",
+  workerUsageDaily: "worker_usage_daily",
+  pendingReports: "pending_reports",
+  reportJobs: "report_jobs",
+  shareableReports: "shareable_reports",
+  conversationFeedback: "conversation_feedback",
+  dataCoverage: "data_coverage",
+  sellerAccountMarketplaceRegistry: "seller_account_marketplace_registry",
+  sellerAccountBillingState: "seller_account_billing_state",
+  sellerAccountBillingMeasurements: "seller_account_billing_measurements",
+  sellerAccountBillingEvents: "seller_account_billing_events",
+  /** @deprecated Use sellerAccountBillingState. */
+  marketplaceBillingState: "seller_account_billing_state",
+  /** @deprecated Use sellerAccountBillingMeasurements. */
+  marketplaceBillingMeasurements: "seller_account_billing_measurements",
+  /** @deprecated Use sellerAccountBillingEvents. */
+  marketplaceBillingEvents: "seller_account_billing_events",
+  // Computed tables
+  seasonalityIndex: "seasonality_index_v1",
+  keywordRanks: "sp_keyword_ranks_v1",
+  // Sales metrics (aggregated)
+  orderMetrics: "sp_order_metrics_v1",
+  // Dashboard tables
+  asinCogs: "asin_cogs",
+  inventoryConfig: "inventory_config"
+};
+var SHARED_ONLY_TABLES = [
+  "agencies",
+  "agency_memberships",
+  "alert_events",
+  "amzn_ads_profiles_v2",
+  "app_users",
+  "remediation_actions",
+  "api_keys",
+  "api_usage_events",
+  "ad_lifecycle_events",
+  "ad_conversion_uploads",
+  "landing_visits",
+  "asin_registry",
+  "data_coverage",
+  "seller_account_marketplace_registry",
+  "seller_account_billing_state",
+  "seller_account_billing_measurements",
+  "seller_account_billing_events",
+  "email_events",
+  "email_verification_tokens",
+  "onboarding_invites",
+  "password_reset_tokens",
+  "pending_reports",
+  "report_jobs",
+  "shareable_reports",
+  "conversation_feedback",
+  "signup_attribution",
+  "sp_ingestion_metadata",
+  "sync_leases",
+  "sync_runs",
+  "pagination_checkpoints",
+  "tenant_capabilities",
+  "bq_usage_daily",
+  "worker_usage_daily",
+  "tenant_ads_profiles",
+  "tenant_marketplace_connections",
+  "tenant_deletion_tombstones",
+  "tenant_memberships",
+  "tenants"
+];
+var SHARED_ONLY_TABLE_SET = new Set(SHARED_ONLY_TABLES);
+var METRIC_EXPRESSIONS = {
+  acos: "CASE WHEN COALESCE(SUM(sales14d), 0) = 0 THEN NULL ELSE ROUND(SAFE_DIVIDE(SUM(cost), SUM(sales14d)) * 100, 2) END",
+  roas: "CASE WHEN COALESCE(SUM(sales14d), 0) = 0 OR COALESCE(SUM(cost), 0) = 0 THEN NULL ELSE ROUND(SAFE_DIVIDE(SUM(sales14d), SUM(cost)), 2) END",
+  ctr: "ROUND(SAFE_DIVIDE(SUM(clicks), SUM(impressions)) * 100, 2)",
+  cpc: "ROUND(SAFE_DIVIDE(SUM(cost), SUM(clicks)), 2)",
+  cvr: "CASE WHEN COALESCE(SUM(purchases14d), 0) = 0 OR COALESCE(SUM(clicks), 0) = 0 THEN NULL ELSE ROUND(SAFE_DIVIDE(SUM(purchases14d), SUM(clicks)) * 100, 2) END"
+};
+var STANDARD_METRICS = `
+  SUM(impressions) AS impressions,
+  SUM(clicks) AS clicks,
+  ROUND(SUM(cost), 2) AS spend,
+  ROUND(SUM(sales14d), 2) AS sales,
+  SUM(purchases14d) AS orders,
+  SUM(units_sold_clicks14d) AS units_sold,
+  ${METRIC_EXPRESSIONS.acos} AS acos,
+  ${METRIC_EXPRESSIONS.roas} AS roas,
+  ${METRIC_EXPRESSIONS.ctr} AS ctr,
+  ${METRIC_EXPRESSIONS.cpc} AS cpc,
+  ${METRIC_EXPRESSIONS.cvr} AS cvr`;
+var DEFAULT_MARKETPLACE_ID = "ATVPDKIKX0DER";
+var DEFAULT_REPORTING_TIME_ZONE = "America/Los_Angeles";
+var SP_API_BASE_URLS = {
+  NA: "https://sellingpartnerapi-na.amazon.com",
+  EU: "https://sellingpartnerapi-eu.amazon.com",
+  FE: "https://sellingpartnerapi-fe.amazon.com"
+};
+var ADS_API_BASE_URLS = {
+  NA: "https://advertising-api.amazon.com",
+  EU: "https://advertising-api-eu.amazon.com",
+  FE: "https://advertising-api-fe.amazon.com"
+};
+var ENABLED_ROLLOUT = {
+  rolloutStatus: "enabled",
+  phase1Enabled: true,
+  oauthConnectEnabled: true
+};
+var MARKETPLACE_DEFINITIONS = [
+  {
+    marketplaceId: "ATVPDKIKX0DER",
+    countryCode: "US",
+    countryName: "United States",
+    amazonDomain: "Amazon.com",
+    currencyCode: "USD",
+    defaultReportingTimeZone: DEFAULT_REPORTING_TIME_ZONE,
+    spApiRegion: "NA",
+    spApiBaseUrl: SP_API_BASE_URLS.NA,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.com",
+    adsRegion: "NA",
+    adsApiBaseUrl: ADS_API_BASE_URLS.NA,
+    rolloutStatus: "foundation",
+    phase1Enabled: true
+  },
+  {
+    marketplaceId: "A1F83G8C2ARO7P",
+    countryCode: "GB",
+    countryName: "United Kingdom",
+    amazonDomain: "Amazon.co.uk",
+    currencyCode: "GBP",
+    defaultReportingTimeZone: "Europe/London",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral-europe.amazon.com",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    rolloutStatus: "foundation",
+    phase1Enabled: true
+  },
+  {
+    marketplaceId: "A17E79C6D8DWNP",
+    countryCode: "SA",
+    countryName: "Saudi Arabia",
+    amazonDomain: "Amazon.sa",
+    currencyCode: "SAR",
+    defaultReportingTimeZone: "Asia/Riyadh",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.sa",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    rolloutStatus: "foundation",
+    phase1Enabled: true
+  },
+  {
+    marketplaceId: "A2EUQ1WTGCTBG2",
+    countryCode: "CA",
+    countryName: "Canada",
+    amazonDomain: "Amazon.ca",
+    currencyCode: "CAD",
+    defaultReportingTimeZone: "America/Toronto",
+    spApiRegion: "NA",
+    spApiBaseUrl: SP_API_BASE_URLS.NA,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.ca",
+    adsRegion: "NA",
+    adsApiBaseUrl: ADS_API_BASE_URLS.NA,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A1AM78C64UM0Y8",
+    countryCode: "MX",
+    countryName: "Mexico",
+    amazonDomain: "Amazon.com.mx",
+    currencyCode: "MXN",
+    defaultReportingTimeZone: "America/Mexico_City",
+    spApiRegion: "NA",
+    spApiBaseUrl: SP_API_BASE_URLS.NA,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.com.mx",
+    adsRegion: "NA",
+    adsApiBaseUrl: ADS_API_BASE_URLS.NA,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A2Q3Y263D00KWC",
+    countryCode: "BR",
+    countryName: "Brazil",
+    amazonDomain: "Amazon.com.br",
+    currencyCode: "BRL",
+    defaultReportingTimeZone: "America/Sao_Paulo",
+    spApiRegion: "NA",
+    spApiBaseUrl: SP_API_BASE_URLS.NA,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.com.br",
+    adsRegion: "NA",
+    adsApiBaseUrl: ADS_API_BASE_URLS.NA,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A28R8C7NBKEWEA",
+    countryCode: "IE",
+    countryName: "Ireland",
+    amazonDomain: "Amazon.ie",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Dublin",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.ie",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A1RKKUPIHCS9HS",
+    countryCode: "ES",
+    countryName: "Spain",
+    amazonDomain: "Amazon.es",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Madrid",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral-europe.amazon.com",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A13V1IB3VIYZZH",
+    countryCode: "FR",
+    countryName: "France",
+    amazonDomain: "Amazon.fr",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Paris",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral-europe.amazon.com",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "AMEN7PMS3EDWL",
+    countryCode: "BE",
+    countryName: "Belgium",
+    amazonDomain: "Amazon.com.be",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Brussels",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.com.be",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A1805IZSGTT6HS",
+    countryCode: "NL",
+    countryName: "Netherlands",
+    amazonDomain: "Amazon.nl",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Amsterdam",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.nl",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A1PA6795UKMFR9",
+    countryCode: "DE",
+    countryName: "Germany",
+    amazonDomain: "Amazon.de",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Berlin",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral-europe.amazon.com",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "APJ6JRA9NG5V4",
+    countryCode: "IT",
+    countryName: "Italy",
+    amazonDomain: "Amazon.it",
+    currencyCode: "EUR",
+    defaultReportingTimeZone: "Europe/Rome",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral-europe.amazon.com",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A2NODRKZP88ZB9",
+    countryCode: "SE",
+    countryName: "Sweden",
+    amazonDomain: "Amazon.se",
+    currencyCode: "SEK",
+    defaultReportingTimeZone: "Europe/Stockholm",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.se",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "AE08WJ6YKNBMC",
+    countryCode: "ZA",
+    countryName: "South Africa",
+    amazonDomain: "Amazon.co.za",
+    currencyCode: "ZAR",
+    defaultReportingTimeZone: "Africa/Johannesburg",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.co.za",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A1C3SOZRARQ6R3",
+    countryCode: "PL",
+    countryName: "Poland",
+    amazonDomain: "Amazon.pl",
+    currencyCode: "PLN",
+    defaultReportingTimeZone: "Europe/Warsaw",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.pl",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "ARBP9OOSHTCHU",
+    countryCode: "EG",
+    countryName: "Egypt",
+    amazonDomain: "Amazon.eg",
+    currencyCode: "EGP",
+    defaultReportingTimeZone: "Africa/Cairo",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.eg",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A33AVAJ2PDY3EV",
+    countryCode: "TR",
+    countryName: "Turkey",
+    amazonDomain: "Amazon.com.tr",
+    currencyCode: "TRY",
+    defaultReportingTimeZone: "Europe/Istanbul",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.com.tr",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A2VIGQ35RCS4UG",
+    countryCode: "AE",
+    countryName: "United Arab Emirates",
+    amazonDomain: "Amazon.ae",
+    currencyCode: "AED",
+    defaultReportingTimeZone: "Asia/Dubai",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.ae",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A21TJRUUN4KGV",
+    countryCode: "IN",
+    countryName: "India",
+    amazonDomain: "Amazon.in",
+    currencyCode: "INR",
+    defaultReportingTimeZone: "Asia/Kolkata",
+    spApiRegion: "EU",
+    spApiBaseUrl: SP_API_BASE_URLS.EU,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.in",
+    adsRegion: "EU",
+    adsApiBaseUrl: ADS_API_BASE_URLS.EU,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A19VAU5U5O7RUS",
+    countryCode: "SG",
+    countryName: "Singapore",
+    amazonDomain: "Amazon.sg",
+    currencyCode: "SGD",
+    defaultReportingTimeZone: "Asia/Singapore",
+    spApiRegion: "FE",
+    spApiBaseUrl: SP_API_BASE_URLS.FE,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.sg",
+    adsRegion: "FE",
+    adsApiBaseUrl: ADS_API_BASE_URLS.FE,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A39IBJ37TRP1C6",
+    countryCode: "AU",
+    countryName: "Australia",
+    amazonDomain: "Amazon.com.au",
+    currencyCode: "AUD",
+    defaultReportingTimeZone: "Australia/Sydney",
+    spApiRegion: "FE",
+    spApiBaseUrl: SP_API_BASE_URLS.FE,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.com.au",
+    adsRegion: "FE",
+    adsApiBaseUrl: ADS_API_BASE_URLS.FE,
+    ...ENABLED_ROLLOUT
+  },
+  {
+    marketplaceId: "A1VC38T7YXB528",
+    countryCode: "JP",
+    countryName: "Japan",
+    amazonDomain: "Amazon.co.jp",
+    currencyCode: "JPY",
+    defaultReportingTimeZone: "Asia/Tokyo",
+    spApiRegion: "FE",
+    spApiBaseUrl: SP_API_BASE_URLS.FE,
+    sellerCentralBaseUrl: "https://sellercentral.amazon.co.jp",
+    adsRegion: "FE",
+    adsApiBaseUrl: ADS_API_BASE_URLS.FE,
+    ...ENABLED_ROLLOUT
+  }
+];
+var MARKETPLACES_BY_ID = Object.freeze(
+  Object.fromEntries(MARKETPLACE_DEFINITIONS.map((marketplace) => [marketplace.marketplaceId, marketplace]))
+);
+function marketplaceIdsForCountryCodes(countryCodes) {
+  return Object.freeze(countryCodes.map((countryCode) => {
+    const marketplace = MARKETPLACE_DEFINITIONS.find((entry) => entry.countryCode === countryCode);
+    if (!marketplace) {
+      throw new Error(`Missing marketplace definition for country code ${countryCode}`);
+    }
+    return marketplace.marketplaceId;
+  }));
+}
+function marketplaceSetForCountryCodes(countryCodes) {
+  return Object.freeze(new Set(marketplaceIdsForCountryCodes(countryCodes)));
+}
+var CUSTOMER_FEEDBACK_SUPPORTED_MARKETPLACE_IDS = Object.freeze(
+  /* @__PURE__ */ new Set([
+    "ATVPDKIKX0DER",
+    // US
+    "A1F83G8C2ARO7P",
+    // UK
+    "A1PA6795UKMFR9",
+    // DE
+    "A1RKKUPIHCS9HS",
+    // ES
+    "A13V1IB3VIYZZH",
+    // FR
+    "APJ6JRA9NG5V4",
+    // IT
+    "A1VC38T7YXB528"
+    // JP
+  ])
+);
+var ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_SUPPORTED_MARKETPLACE_IDS = marketplaceSetForCountryCodes([
+  "US",
+  "CA",
+  "MX",
+  "BR",
+  "DE",
+  "ES",
+  "FR",
+  "IT",
+  "GB",
+  "NL",
+  "SE",
+  "TR",
+  "PL",
+  "BE",
+  "AE",
+  "EG",
+  "SA",
+  "JP",
+  "IN",
+  "AU",
+  "SG",
+  "ZA"
+]);
+var ADS_SPONSORED_PRODUCTS_BID_RECOMMENDATION_SUPPORTED_MARKETPLACE_IDS = marketplaceSetForCountryCodes(["US", "CA", "DE", "ES", "FR", "GB", "JP", "IN"]);
+var ADS_SPONSORED_PRODUCTS_BUDGET_RECOMMENDATION_SUPPORTED_MARKETPLACE_IDS = marketplaceSetForCountryCodes(["US", "CA", "MX", "DE", "ES", "FR", "GB", "IT", "JP", "IN", "AU", "AE"]);
+var ADS_BRAND_METRICS_SUPPORTED_MARKETPLACE_IDS = marketplaceSetForCountryCodes(["US", "CA", "MX", "GB", "DE", "FR", "IN", "IT", "ES", "JP", "AU"]);
+var BRAND_ANALYTICS_REPORT_SUPPORTED_MARKETPLACE_IDS = marketplaceSetForCountryCodes([
+  "US",
+  "CA",
+  "MX",
+  "BR",
+  "ES",
+  "GB",
+  "FR",
+  "NL",
+  "DE",
+  "IT",
+  "SE",
+  "TR",
+  "SA",
+  "AE",
+  "IN",
+  "SG",
+  "AU",
+  "JP"
+]);
+var FULFILLMENT_INBOUND_SUPPORTED_MARKETPLACE_IDS = Object.freeze(
+  new Set(MARKETPLACE_DEFINITIONS.filter((marketplace) => marketplace.countryCode !== "BR").map((marketplace) => marketplace.marketplaceId))
+);
+var FBA_INVENTORY_PLANNING_UNSUPPORTED_COUNTRY_CODES = /* @__PURE__ */ new Set(["NL", "PL", "SE", "BE"]);
+var FBA_INVENTORY_PLANNING_SUPPORTED_MARKETPLACE_IDS = Object.freeze(
+  new Set(MARKETPLACE_DEFINITIONS.filter((marketplace) => !FBA_INVENTORY_PLANNING_UNSUPPORTED_COUNTRY_CODES.has(marketplace.countryCode)).map((marketplace) => marketplace.marketplaceId))
+);
+var AWD_SUPPORTED_MARKETPLACE_IDS = marketplaceSetForCountryCodes(["US"]);
+var MARKETPLACE_NAMES = Object.freeze(
+  Object.fromEntries(MARKETPLACE_DEFINITIONS.map((marketplace) => [marketplace.marketplaceId, marketplace.countryName]))
+);
+function getMarketplaceDefinition(marketplaceId) {
+  if (!marketplaceId) return void 0;
+  return MARKETPLACES_BY_ID[marketplaceId];
+}
+var MARKETPLACE_ORDER_TIER_IDS = [
+  "starter",
+  "growth",
+  "scale",
+  "business",
+  "enterprise"
+];
+var SELLER_ACCOUNT_ORDER_TIER_IDS = MARKETPLACE_ORDER_TIER_IDS;
+var MARKETPLACE_ORDER_TIERS = [
+  {
+    id: "starter",
+    displayName: "Starter",
+    minOrdersInclusive: 0,
+    maxOrdersInclusive: 1e3,
+    monthlyUsd: 39,
+    monthlyPriceCents: 3900
+  },
+  {
+    id: "growth",
+    displayName: "Growth",
+    minOrdersInclusive: 1001,
+    maxOrdersInclusive: 5e3,
+    monthlyUsd: 69,
+    monthlyPriceCents: 6900
+  },
+  {
+    id: "scale",
+    displayName: "Scale",
+    minOrdersInclusive: 5001,
+    maxOrdersInclusive: 1e4,
+    monthlyUsd: 99,
+    monthlyPriceCents: 9900
+  },
+  {
+    id: "business",
+    displayName: "Business",
+    minOrdersInclusive: 10001,
+    maxOrdersInclusive: 25e3,
+    monthlyUsd: 199,
+    monthlyPriceCents: 19900
+  },
+  {
+    id: "enterprise",
+    displayName: "Enterprise",
+    minOrdersInclusive: 25001,
+    maxOrdersInclusive: null,
+    monthlyUsd: null,
+    monthlyPriceCents: null
+  }
+];
+var SELLER_ACCOUNT_BILLING_STATUSES = [
+  "trialing",
+  "active",
+  "past_due",
+  "canceled",
+  "provisional",
+  "custom",
+  "disabled"
+];
+var SELLER_ACCOUNT_BILLING_MEASUREMENT_SOURCES = [
+  "order_metrics",
+  "raw_orders",
+  "manual",
+  "unavailable"
+];
+var SELLER_ACCOUNT_BILLING_MEASUREMENT_CONFIDENCES = [
+  "final",
+  "partial",
+  "provisional",
+  "unavailable",
+  "manual"
+];
+var TIER_INDEX_BY_ID = new Map(
+  MARKETPLACE_ORDER_TIERS.map((tier, index) => [tier.id, index])
+);
+var TIER_BY_ID = new Map(
+  MARKETPLACE_ORDER_TIERS.map((tier) => [tier.id, tier])
+);
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+var DATE_ERROR = "Expected date string in YYYY-MM-DD format";
+var CALENDAR_DATE_ERROR = "Expected valid calendar date in YYYY-MM-DD format";
+var TIMESTAMP_ERROR = "Expected parseable timestamp";
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function isValidCalendarDateString(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (year < 1 || month < 1 || month > 12) {
+    return false;
+  }
+  const daysInMonth = [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return day >= 1 && day <= daysInMonth[month - 1];
+}
+function isParseableTimestampString(value) {
+  if (!Number.isFinite(Date.parse(value))) {
+    return false;
+  }
+  const leadingDate = /^(\d{4}-\d{2}-\d{2})(?:[T\s]|$)/.exec(value);
+  if (leadingDate && !isValidCalendarDateString(leadingDate[1])) {
+    return false;
+  }
+  return true;
+}
+var dateSchema = z2.string({ invalid_type_error: DATE_ERROR }).regex(DATE_PATTERN, DATE_ERROR).describe("Date (YYYY-MM-DD)");
+var DEFAULT_TOOL_LIMIT = 20;
+var MAX_TOOL_LIMIT = 1e3;
+function toolLimitParam(description = `Max rows (1-${MAX_TOOL_LIMIT}, default ${DEFAULT_TOOL_LIMIT}).`, options) {
+  const max = options?.max ?? MAX_TOOL_LIMIT;
+  const defaultValue = options?.defaultValue ?? DEFAULT_TOOL_LIMIT;
+  return z2.number().int().min(1).max(max).default(defaultValue).describe(description);
+}
+function optionalDateParam(description) {
+  return z2.preprocess(
+    (value) => value === null ? void 0 : value,
+    z2.string({ invalid_type_error: DATE_ERROR }).regex(DATE_PATTERN, DATE_ERROR).optional()
+  ).describe(description);
+}
+var AGENCY_STATUSES = ["pilot", "active", "paused", "disabled"];
+var APP_USER_STATUSES = ["active", "invited", "disabled", "deleted"];
+var AGENCY_MEMBERSHIP_ROLES = ["owner", "admin", "member"];
+var TENANT_MEMBERSHIP_ROLES = ["owner", "admin", "member", "read_only"];
+var MEMBERSHIP_STATUSES = ["invited", "active", "disabled", "deleted"];
+var TENANT_BILLING_OWNERS = ["self_serve", "agency", "manual"];
+var TENANT_BILLING_MODES = ["standard", "custom_agency", "covered"];
+var agencyStatusSchema = z2.enum(AGENCY_STATUSES);
+var appUserStatusSchema = z2.enum(APP_USER_STATUSES);
+var agencyMembershipRoleSchema = z2.enum(AGENCY_MEMBERSHIP_ROLES);
+var tenantMembershipRoleSchema = z2.enum(TENANT_MEMBERSHIP_ROLES);
+var membershipStatusSchema = z2.enum(MEMBERSHIP_STATUSES);
+var tenantBillingOwnerSchema = z2.enum(TENANT_BILLING_OWNERS);
+var tenantBillingModeSchema = z2.enum(TENANT_BILLING_MODES);
+var nonEmptyStringSchema = z2.string().min(1);
+var nullableStringSchema = nonEmptyStringSchema.nullable();
+var timestampStringSchema = nonEmptyStringSchema;
+var nullableTimestampStringSchema = timestampStringSchema.nullable();
+var sellerAccountMarketplaceRegistryDateSchema = z2.string({ invalid_type_error: CALENDAR_DATE_ERROR }).regex(DATE_PATTERN, CALENDAR_DATE_ERROR).refine(isValidCalendarDateString, CALENDAR_DATE_ERROR);
+var nullableSellerAccountMarketplaceRegistryDateSchema = sellerAccountMarketplaceRegistryDateSchema.nullable();
+var nullableDateSchema = dateSchema.nullable();
+var sellerAccountMarketplaceRegistryTimestampSchema = z2.string({ invalid_type_error: TIMESTAMP_ERROR }).min(1, TIMESTAMP_ERROR).refine(isParseableTimestampString, TIMESTAMP_ERROR);
+var nullableSellerAccountMarketplaceRegistryTimestampSchema = sellerAccountMarketplaceRegistryTimestampSchema.nullable();
+var nonNegativeIntegerSchema = z2.number().int().nonnegative();
+var nullableNonNegativeIntegerSchema = nonNegativeIntegerSchema.nullable();
+var sellerAccountOrderTierSchema = z2.enum(SELLER_ACCOUNT_ORDER_TIER_IDS);
+var sellerAccountBillingStatusSchema = z2.enum(SELLER_ACCOUNT_BILLING_STATUSES);
+var sellerAccountBillingMeasurementSourceSchema = z2.enum(SELLER_ACCOUNT_BILLING_MEASUREMENT_SOURCES);
+var sellerAccountBillingMeasurementConfidenceSchema = z2.enum(
+  SELLER_ACCOUNT_BILLING_MEASUREMENT_CONFIDENCES
+);
+var SELLER_ACCOUNT_MARKETPLACE_REGISTRY_STATUSES = ["draft", "verified", "superseded"];
+var SELLER_ACCOUNT_MARKETPLACE_CONNECTION_STATUSES = [
+  "pending",
+  "active",
+  "reconnect_needed",
+  "disconnected",
+  "archived"
+];
+var SELLER_ACCOUNT_RAW_ORDERS_COVERAGE_ROLES = ["candidate", "expected", "excluded"];
+var SELLER_ACCOUNT_MARKETPLACE_VERIFICATION_SOURCES = [
+  "operator_verified",
+  "amazon_discovery",
+  "seller_central_oauth",
+  "migration",
+  "support_override"
+];
+var sellerAccountMarketplaceRegistryStatusSchema = z2.enum(
+  SELLER_ACCOUNT_MARKETPLACE_REGISTRY_STATUSES
+);
+var sellerAccountMarketplaceConnectionStatusSchema = z2.enum(
+  SELLER_ACCOUNT_MARKETPLACE_CONNECTION_STATUSES
+);
+var sellerAccountRawOrdersCoverageRoleSchema = z2.enum(
+  SELLER_ACCOUNT_RAW_ORDERS_COVERAGE_ROLES
+);
+var sellerAccountMarketplaceVerificationSourceSchema = z2.enum(
+  SELLER_ACCOUNT_MARKETPLACE_VERIFICATION_SOURCES
+);
+var sellerAccountBillingMeasurementRowSchema = z2.object({
+  measurement_id: nonEmptyStringSchema,
+  tenant_id: nonEmptyStringSchema,
+  connection_id: nonEmptyStringSchema,
+  marketplace_id: nonEmptyStringSchema,
+  period_start: dateSchema,
+  period_end: dateSchema,
+  reporting_time_zone: nonEmptyStringSchema,
+  orders_30d: nullableNonNegativeIntegerSchema,
+  units_30d: nullableNonNegativeIntegerSchema,
+  source: sellerAccountBillingMeasurementSourceSchema,
+  confidence: sellerAccountBillingMeasurementConfidenceSchema,
+  computed_tier: sellerAccountOrderTierSchema,
+  computed_at: timestampStringSchema,
+  details_json: nullableStringSchema
+}).strict();
+var sellerAccountBillingStateRowSchema = z2.object({
+  billing_state_id: nonEmptyStringSchema,
+  tenant_id: nonEmptyStringSchema,
+  connection_id: nonEmptyStringSchema,
+  marketplace_id: nonEmptyStringSchema,
+  billing_status: sellerAccountBillingStatusSchema,
+  billing_tier: sellerAccountOrderTierSchema,
+  pending_billing_tier: sellerAccountOrderTierSchema.nullable(),
+  stripe_customer_id: nullableStringSchema,
+  stripe_subscription_id: nullableStringSchema,
+  stripe_subscription_item_id: nullableStringSchema,
+  stripe_price_id: nullableStringSchema,
+  last_measured_orders_30d: nullableNonNegativeIntegerSchema,
+  last_measured_units_30d: nullableNonNegativeIntegerSchema,
+  last_measurement_source: sellerAccountBillingMeasurementSourceSchema,
+  last_measurement_confidence: sellerAccountBillingMeasurementConfidenceSchema,
+  last_measured_period_start: nullableDateSchema,
+  last_measured_period_end: nullableDateSchema,
+  last_measured_at: nullableTimestampStringSchema,
+  consecutive_months_below_tier: nonNegativeIntegerSchema,
+  tier_effective_at: nullableTimestampStringSchema,
+  pending_tier_effective_at: nullableTimestampStringSchema,
+  manual_billing_override: z2.boolean(),
+  manual_billing_override_reason: nullableStringSchema,
+  created_at: timestampStringSchema,
+  updated_at: timestampStringSchema
+}).strict();
+var sellerAccountBillingEventRowSchema = z2.object({
+  event_id: nonEmptyStringSchema,
+  tenant_id: nonEmptyStringSchema,
+  connection_id: nonEmptyStringSchema,
+  marketplace_id: nonEmptyStringSchema,
+  event_type: nonEmptyStringSchema,
+  from_tier: sellerAccountOrderTierSchema.nullable(),
+  to_tier: sellerAccountOrderTierSchema.nullable(),
+  orders_30d: nullableNonNegativeIntegerSchema,
+  stripe_subscription_id: nullableStringSchema,
+  stripe_subscription_item_id: nullableStringSchema,
+  stripe_price_id: nullableStringSchema,
+  effective_at: nullableTimestampStringSchema,
+  metadata_json: nullableStringSchema,
+  created_at: timestampStringSchema
+}).strict();
+var sellerAccountMarketplaceRegistryRowSchema = z2.object({
+  registry_entry_id: nonEmptyStringSchema,
+  registry_version_id: nonEmptyStringSchema,
+  registry_status: sellerAccountMarketplaceRegistryStatusSchema,
+  tenant_id: nonEmptyStringSchema,
+  seller_id: nonEmptyStringSchema,
+  connection_id: nonEmptyStringSchema,
+  marketplace_id: nonEmptyStringSchema,
+  country_code: nonEmptyStringSchema,
+  currency_code: nonEmptyStringSchema,
+  reporting_time_zone: nonEmptyStringSchema,
+  connection_status: sellerAccountMarketplaceConnectionStatusSchema,
+  raw_orders_coverage_role: sellerAccountRawOrdersCoverageRoleSchema,
+  raw_orders_coverage_start_date: nullableSellerAccountMarketplaceRegistryDateSchema,
+  raw_orders_coverage_end_date: nullableSellerAccountMarketplaceRegistryDateSchema,
+  coverage_exclusion_reason: nullableStringSchema,
+  verification_source: sellerAccountMarketplaceVerificationSourceSchema,
+  verified_at: nullableSellerAccountMarketplaceRegistryTimestampSchema,
+  evidence_json: nullableStringSchema,
+  created_at: sellerAccountMarketplaceRegistryTimestampSchema,
+  updated_at: sellerAccountMarketplaceRegistryTimestampSchema
+}).strict().superRefine((row, ctx) => {
+  if (row.marketplace_id === "seller_account") {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["marketplace_id"],
+      message: "marketplace_id must be an actual Amazon marketplace ID, not seller_account"
+    });
+  } else if (!getMarketplaceDefinition(row.marketplace_id)) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["marketplace_id"],
+      message: "marketplace_id must be a supported canonical Amazon marketplace ID"
+    });
+  }
+  if (row.registry_status === "verified" && row.raw_orders_coverage_role === "candidate") {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["raw_orders_coverage_role"],
+      message: "verified registry versions cannot contain unresolved candidate marketplaces"
+    });
+  }
+  if (row.registry_status === "verified" && !row.verified_at) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["verified_at"],
+      message: "verified registry rows require verified_at"
+    });
+  }
+  if (row.raw_orders_coverage_role === "expected" && !row.raw_orders_coverage_start_date) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["raw_orders_coverage_start_date"],
+      message: "expected raw-orders coverage rows require raw_orders_coverage_start_date"
+    });
+  }
+  if (row.raw_orders_coverage_role === "excluded" && !row.coverage_exclusion_reason) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: ["coverage_exclusion_reason"],
+      message: "excluded raw-orders coverage rows require coverage_exclusion_reason"
+    });
+  }
+});
+var baseToolParams = {
+  start_date: optionalDateParam("Optional. YYYY-MM-DD. Defaults to 30 days ago if omitted."),
+  end_date: optionalDateParam("Optional. YYYY-MM-DD. Defaults to today if omitted."),
+  profile_id: z2.string().optional().describe("Filter by profile ID"),
+  campaign_name: z2.string().optional().describe("Filter by campaign name (LIKE match, use % for wildcards)"),
+  sort_order: z2.enum(["asc", "desc"]).default("desc").describe("Sort order"),
+  limit: toolLimitParam()
+};
+var baseInventoryParams = {
+  asin: z2.string().optional().describe("Filter by ASIN"),
+  sku: z2.string().optional().describe("Filter by SKU"),
+  sort_order: z2.enum(["asc", "desc"]).default("desc").describe("Sort order"),
+  limit: toolLimitParam()
+};
+var DISABLE_WRITE_TOOLS_FOR_DOMAIN_PREFIX = "__write_tools_disabled__:";
+var TOOL_DOMAINS = [
+  {
+    name: "Ads",
+    serverDomain: "ads",
+    tools: [
+      { name: "get_campaign_performance", description: "Campaign health, spend, and ACOS metrics" },
+      { name: "get_campaign_snapshots", description: "Campaign setting history and change detection" },
+      { name: "get_ads_change_history", description: "Timestamped Amazon Ads entity change events" },
+      { name: "get_adgroup_performance", description: "Ad group level performance breakdown" },
+      { name: "get_keyword_performance", description: "Keyword bid and targeting analysis" },
+      { name: "get_product_performance", description: "Sponsored Products advertised-ASIN performance" },
+      { name: "get_purchased_products", description: "Products purchased from ad clicks" },
+      { name: "get_search_terms", description: "SP/SB customer search terms that triggered ads" },
+      { name: "get_placement_breakdown", description: "Performance by ad placement" },
+      { name: "get_sb_campaign_performance", description: "Sponsored Brands campaign metrics" },
+      { name: "get_sd_campaign_performance", description: "Sponsored Display campaign metrics" },
+      { name: "get_sponsored_ads_report", description: "Consolidated SP/SB/SD retained report views" },
+      { name: "get_dsp_performance", description: "Amazon DSP order, line item, and creative metrics" },
+      { name: "get_dsp_advertisers_live", description: "Live Amazon DSP advertiser records" },
+      { name: "get_dsp_entities_live", description: "Live Amazon DSP campaigns, ad groups, and targets" },
+      { name: "get_store_performance", description: "Brand Store traffic, page, source, tag, and sales insights" },
+      { name: "get_portfolio_performance", description: "Sponsored Products portfolio-level performance rollups" },
+      { name: "get_sales_and_traffic", description: "Sales and traffic by ASIN" },
+      { name: "get_tacos", description: "Total ad cost of sales per ASIN" },
+      { name: "get_search_query_performance", description: "Market share and conversion data" },
+      { name: "get_repeat_purchase_behavior", description: "Brand Analytics repeat-purchase behavior by ASIN" },
+      { name: "get_search_query_ad_coverage", description: "Search queries with and without ad coverage" },
+      { name: "diagnose_performance", description: "SP/SB/SD root cause analysis between date ranges" },
+      { name: "get_sp_entities_live", description: "Live Sponsored Products entity state from Amazon" },
+      { name: "get_sponsored_ads_entities_live", description: "Live SP/SB/SD entity state from Amazon" },
+      { name: "get_sp_targeting_options", description: "Targeting candidates, categories, and negative brands" },
+      { name: "get_sponsored_ads_targeting_options", description: "Live SP/SB/SD targeting options and bid fields" },
+      { name: "create_sb_campaigns", description: "Preview or create Sponsored Brands campaigns", write: true },
+      { name: "update_sb_campaign_budget", description: "Preview or update Sponsored Brands campaign budgets", write: true },
+      { name: "update_sb_campaign_state", description: "Preview or set Sponsored Brands campaign state", write: true },
+      { name: "archive_sb_campaigns", description: "Preview or archive Sponsored Brands campaigns", write: true },
+      { name: "create_sb_ad_groups", description: "Preview or create Sponsored Brands ad groups", write: true },
+      { name: "update_sb_ad_group_state", description: "Preview or set Sponsored Brands ad group state", write: true },
+      { name: "archive_sb_ad_groups", description: "Preview or archive Sponsored Brands ad groups", write: true },
+      { name: "create_sb_ads", description: "Preview or create Sponsored Brands ads with caller-supplied creative", write: true },
+      { name: "update_sb_ad_state", description: "Preview or set Sponsored Brands ad state", write: true },
+      { name: "archive_sb_ads", description: "Preview or archive Sponsored Brands ads", write: true },
+      { name: "create_sb_targets", description: "Preview or create Sponsored Brands targets", write: true },
+      { name: "update_sb_target_bids", description: "Preview or update Sponsored Brands target bids", write: true },
+      { name: "update_sb_target_state", description: "Preview or set Sponsored Brands target state", write: true },
+      { name: "archive_sb_targets", description: "Preview or archive Sponsored Brands targets", write: true },
+      { name: "create_sb_negative_targets", description: "Preview or create Sponsored Brands negative targets", write: true },
+      { name: "update_sb_negative_target_state", description: "Preview or set Sponsored Brands negative target state", write: true },
+      { name: "archive_sb_negative_targets", description: "Preview or archive Sponsored Brands negative targets", write: true },
+      { name: "update_keyword_bids", description: "Preview or adjust keyword bids", write: true },
+      { name: "update_target_bids", description: "Preview or adjust Sponsored Products target bids", write: true },
+      { name: "update_keyword_state", description: "Preview or set keyword state", write: true },
+      { name: "archive_keywords", description: "Preview or archive keywords", write: true },
+      { name: "update_adgroup_bid", description: "Preview or update ad group default bids", write: true },
+      { name: "update_campaign_bidding", description: "Preview or adjust placement bid modifiers", write: true },
+      { name: "update_campaign_budget", description: "Preview or change daily campaign budget", write: true },
+      { name: "update_campaign_state", description: "Preview or set campaign state", write: true },
+      { name: "archive_campaigns", description: "Preview or archive Sponsored Products campaigns", write: true },
+      { name: "create_sd_campaigns", description: "Preview or create Sponsored Display campaigns", write: true },
+      { name: "update_sd_campaign_budget", description: "Preview or update Sponsored Display campaign budgets", write: true },
+      { name: "update_sd_campaign_state", description: "Preview or set Sponsored Display campaign state", write: true },
+      { name: "archive_sd_campaigns", description: "Preview or archive Sponsored Display campaigns", write: true },
+      { name: "create_sd_ad_groups", description: "Preview or create Sponsored Display ad groups", write: true },
+      { name: "update_sd_ad_group_bid", description: "Preview or update Sponsored Display ad group default bids", write: true },
+      { name: "update_sd_ad_group_state", description: "Preview or set Sponsored Display ad group state", write: true },
+      { name: "archive_sd_ad_groups", description: "Preview or archive Sponsored Display ad groups", write: true },
+      { name: "create_sd_product_ads", description: "Preview or create Sponsored Display product ads", write: true },
+      { name: "update_sd_product_ad_state", description: "Preview or set Sponsored Display product ad state", write: true },
+      { name: "archive_sd_product_ads", description: "Preview or archive Sponsored Display product ads", write: true },
+      { name: "create_sd_targets", description: "Preview or create Sponsored Display targets", write: true },
+      { name: "update_sd_target_bids", description: "Preview or update Sponsored Display target bids", write: true },
+      { name: "update_sd_target_state", description: "Preview or set Sponsored Display target state", write: true },
+      { name: "archive_sd_targets", description: "Preview or archive Sponsored Display targets", write: true },
+      { name: "create_sd_negative_targets", description: "Preview or create Sponsored Display negative targets", write: true },
+      { name: "update_sd_negative_target_state", description: "Preview or set Sponsored Display negative target state", write: true },
+      { name: "archive_sd_negative_targets", description: "Preview or archive Sponsored Display negative targets", write: true },
+      { name: "update_campaign_audience_bid_adjustment", description: "Preview or set audience bid adjustments", write: true },
+      { name: "create_keywords", description: "Preview or add keywords", write: true },
+      { name: "create_negative_keywords", description: "Preview or add negative keywords", write: true },
+      { name: "create_sp_campaigns", description: "Preview or create Sponsored Products campaigns", write: true },
+      { name: "create_sp_ad_groups", description: "Preview or create Sponsored Products ad groups", write: true },
+      { name: "create_sp_product_ads", description: "Preview or create Sponsored Products product ads", write: true },
+      { name: "update_sp_ad_entities", description: "Preview or update/archive Sponsored Products ad groups and product ads", write: true },
+      { name: "create_sp_targets", description: "Preview or create Sponsored Products targeting clauses", write: true },
+      { name: "update_sp_target_state", description: "Preview or set Sponsored Products target state", write: true },
+      { name: "archive_sp_targets", description: "Preview or archive Sponsored Products targets", write: true },
+      { name: "create_sp_negative_targets", description: "Preview or create Sponsored Products negative ASIN/brand targets", write: true },
+      { name: "update_sp_negative_keyword_state", description: "Preview or set Sponsored Products negative keyword state", write: true },
+      { name: "archive_sp_negative_keywords", description: "Preview or archive Sponsored Products negative keywords", write: true },
+      { name: "update_sp_negative_target_state", description: "Preview or set Sponsored Products negative target state", write: true },
+      { name: "archive_sp_negative_targets", description: "Preview or archive Sponsored Products negative targets", write: true },
+      { name: "get_bid_recommendations", description: "Live suggested bids from Amazon" },
+      { name: "get_budget_recommendations", description: "Live Amazon budget suggestion fields" },
+      { name: "get_budget_pacing", description: "Daily campaign budget usage and pacing snapshots" },
+      { name: "get_ad_eligibility", description: "Check ASIN eligibility for ad types" },
+      { name: "get_brand_health", description: "Brand Metrics funnel and peer benchmarks" },
+      { name: "get_share_of_voice", description: "Brand Metrics visibility and engagement signals" },
+      { name: "get_attribution_performance", description: "Off-Amazon Amazon Attribution performance" },
+      { name: "get_audience_segments", description: "Live Amazon Ads audience segment discovery" }
+    ]
+  },
+  {
+    name: "Inventory",
+    serverDomain: "inventory",
+    tools: [
+      { name: "get_fba_inventory", description: "FBA stock levels and quantities" },
+      { name: "get_inventory_health", description: "Age buckets, weeks of cover, storage fee exposure" },
+      { name: "get_fba_storage_fees", description: "FBA monthly and long-term storage fee rows by ASIN/FNSKU/SKU" },
+      { name: "get_inventory_movements", description: "Inventory change history" },
+      { name: "get_inventory_by_fulfillment_center", description: "Stock levels per fulfillment center" },
+      { name: "get_awd_inventory", description: "AWD inbound and on-hand stock" },
+      { name: "get_awd_shipments", description: "AWD shipment tracking" },
+      { name: "get_awd_shipment_items", description: "Per-SKU AWD shipment quantities" },
+      { name: "get_inbound_shipments", description: "FBA inbound shipment tracking" },
+      { name: "get_shipment_receiving_status", description: "Per-SKU receiving progress" },
+      { name: "get_sales_velocity", description: "Daily sales and traffic time series" },
+      { name: "get_listing_registry", description: "Active listing registry, search, and brand ASIN views" },
+      { name: "get_suppressed_listings", description: "Suppressed and stranded listings" },
+      { name: "get_days_of_cover", description: "Days of stock remaining" },
+      { name: "get_todays_sales", description: "Today's priced/estimated revenue by ASIN" },
+      { name: "get_orders", description: "Order list with filters" },
+      { name: "get_order_details", description: "Per-order line items" },
+      { name: "get_returns", description: "FBA return records" },
+      { name: "get_reimbursements", description: "FBA reimbursement records" },
+      { name: "get_seasonality_index", description: "52-week demand curve with events" },
+      { name: "get_sales_summary", description: "Daily final/priced revenue and estimates" },
+      { name: "get_inventory_risk_triage", description: "SKUs at risk: low stock, overstock, aged, or stranded" },
+      { name: "get_current_rank", description: "Live keyword rank check via catalog search" },
+      { name: "get_buybox_status", description: "Live Buy Box status plus daily win-rate history" },
+      { name: "get_competitive_pricing", description: "Live price points plus historical pricing snapshots" },
+      { name: "get_offer_listings", description: "Live seller offers for an ASIN" },
+      { name: "get_subscribe_and_save", description: "Subscribe & Save offer status, history, and Amazon-provided metrics" },
+      { name: "get_fba_eligibility", description: "Check FBA eligibility per ASIN" },
+      { name: "get_listing_restrictions", description: "Listing restrictions and approvals" }
+    ]
+  },
+  {
+    name: "Finance",
+    serverDomain: "finance",
+    tools: [
+      { name: "get_financial_events", description: "Financial event fee breakdown by ASIN/order and profitability views" },
+      { name: "get_profitability_review", description: "Per-ASIN profitability across fees, returns, and ad spend" },
+      { name: "get_payment_transactions", description: "Live Amazon Payments transaction rows and summaries" },
+      { name: "get_settlement_economics", description: "Settlement-finalized financial data" }
+    ]
+  },
+  {
+    name: "Catalog",
+    serverDomain: "catalog",
+    tools: [
+      { name: "get_product_details", description: "Product info, images, dimensions" },
+      { name: "get_sales_ranks", description: "Best seller rank by category" },
+      { name: "get_aplus_status", description: "A+ Content status and associated ASINs" },
+      { name: "get_variations", description: "Parent/child variation relationships" },
+      { name: "get_product_reviews", description: "Customer review topics and snippets" },
+      { name: "get_review_trends", description: "Six-month review topic trends" },
+      { name: "get_listing_quality", description: "Listing completeness scores and issues" },
+      { name: "get_catalog_cleanup", description: "Listings with quality issues to fix" },
+      { name: "create_listing", description: "Validate or submit a listing creation request", write: true },
+      { name: "update_listing", description: "Update listing attributes with preview and audit trail", write: true },
+      { name: "update_price", description: "Submit listing price updates through the Listings Items API", write: true },
+      { name: "update_inventory_quantity", description: "Update seller-fulfilled listing quantities", write: true }
+    ]
+  },
+  {
+    name: "Ranking",
+    serverDomain: "ranking",
+    tools: [
+      { name: "get_keyword_ranks", description: "Keyword rank positions, changes, and SQP volume views" }
+    ]
+  },
+  {
+    name: "Fulfillment",
+    serverDomain: "fulfillment",
+    tools: [
+      { name: "get_shipping_preview", description: "MCF shipping options and cost estimates" },
+      { name: "get_mcf_orders", description: "Multi-Channel Fulfillment order list" },
+      { name: "create_mcf_order", description: "Submit MCF order request from FBA inventory", write: true },
+      { name: "manage_returns", description: "MCF return authorization", write: true }
+    ]
+  }
+];
+var DISABLED_WRITE_TOOL_MARKERS = TOOL_DOMAINS.map(
+  (domain) => `${DISABLE_WRITE_TOOLS_FOR_DOMAIN_PREFIX}${domain.serverDomain}`
+);
+var UTILITY_TOOLS = [
+  {
+    name: "get_account_data_tour",
+    description: "Return a first-run account data tour with trust preflight, business pulse, spotlight products, neutral cross-domain signals, and evidence handles"
+  },
+  {
+    name: "submit_conversation_feedback",
+    description: "Submit a redacted structured product-quality report after the user explicitly asks agentcentral to receive feedback"
+  },
+  {
+    name: "get_account_info",
+    description: "Return the marketplace scope, connection status, tool availability, and next-step guidance for the active API key"
+  },
+  {
+    name: "get_action_history",
+    description: "Return tenant-wide write audit history when the active API key has action-history read permission"
+  }
+];
+var TOOL_COUNTS_BY_DOMAIN = TOOL_DOMAINS.reduce(
+  (counts, domain) => {
+    counts[domain.serverDomain] = {
+      domainTools: domain.tools.length,
+      writeTools: domain.tools.filter((tool) => tool.write).length
+    };
+    return counts;
+  },
+  {}
+);
+var DATA_DOMAIN_COUNT = TOOL_DOMAINS.length;
+var DOMAIN_SCOPED_TOOL_COUNT = TOOL_DOMAINS.reduce((sum, domain) => sum + domain.tools.length, 0);
+var UTILITY_TOOL_COUNT = UTILITY_TOOLS.length;
+var SHIPPED_TOOL_COUNT = DOMAIN_SCOPED_TOOL_COUNT + UTILITY_TOOL_COUNT;
+var WRITE_TOOL_COUNT = TOOL_DOMAINS.reduce(
+  (sum, domain) => sum + domain.tools.filter((tool) => tool.write).length,
+  0
+);
+var TOOL_NAMES = /* @__PURE__ */ new Set(
+  [
+    ...TOOL_DOMAINS.flatMap((d) => d.tools.map((t) => t.name)),
+    ...UTILITY_TOOLS.map((t) => t.name)
+  ]
+);
+var DOMAIN_WRITE_TOOL_NAMES = new Set(
+  TOOL_DOMAINS.flatMap(
+    (domain) => domain.tools.filter((tool) => tool.write).map((tool) => tool.name)
+  )
+);
+var VALID_DISABLED_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ...TOOL_NAMES,
+  ...DISABLED_WRITE_TOOL_MARKERS
+]);
+var CURRENT_WRITE_TOOL_NAMES_BY_DOMAIN = TOOL_DOMAINS.reduce(
+  (byDomain, domain) => {
+    byDomain[domain.serverDomain] = domain.tools.filter((tool) => tool.write).map((tool) => tool.name);
+    return byDomain;
+  },
+  {}
+);
+var DATA_COVERAGE_STATUSES = ["success", "partial", "failure"];
+var DATA_COVERAGE_GRANULARITIES = ["day", "week", "month", "quarter", "snapshot", "event"];
+var DataCoverageStatusSchema = z22.enum(DATA_COVERAGE_STATUSES);
+var DataCoverageGranularitySchema = z22.enum(DATA_COVERAGE_GRANULARITIES);
+var DataCoverageRowSchema = z22.object({
+  coverage_id: z22.string(),
+  tenant_id: z22.string(),
+  sync_mode: z22.string(),
+  table_name: z22.string(),
+  source_type: z22.string(),
+  coverage_granularity: DataCoverageGranularitySchema,
+  coverage_start_date: z22.string().nullable(),
+  coverage_end_date: z22.string().nullable(),
+  marketplace_id: z22.string().nullable(),
+  connection_id: z22.string().nullable().optional(),
+  profile_id: z22.string().nullable(),
+  status: DataCoverageStatusSchema,
+  rows_loaded: z22.number().int().nonnegative(),
+  checked_at: z22.string(),
+  error_message: z22.string().nullable(),
+  trigger_source: z22.string(),
+  snapshot_date: z22.string()
+});
+var ADS_DAILY_LAG_DAYS = 1;
+var ADS_LOOKBACK_DAYS = 14;
+var SP_DAILY_LAG_DAYS = 1;
+var SP_LOOKBACK_DAYS = 14;
+var SNAPSHOT_FRESHNESS_HOURS = 36;
+var WEEKLY_LAG_DAYS = 8;
+var DATA_HEALTH_TABLE_POLICIES = [
+  { syncMode: "campaign_snapshots", tableName: TABLES.campaignSnapshots, label: "SP campaign entity snapshot", coverageGranularity: "snapshot", required: true, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "ad_change_history", tableName: TABLES.adsChangeHistory, label: "Amazon Ads change history", coverageGranularity: "event", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: 90 },
+  { syncMode: "budget_usage", tableName: TABLES.budgetUsage, label: "SP budget usage snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "attribution", tableName: TABLES.attributionPerformance, label: "Amazon Attribution", coverageGranularity: "day", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "dsp_reporting", tableName: TABLES.dspPerformance, label: "DSP performance", coverageGranularity: "day", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "store_insights", tableName: TABLES.storeInsights, label: "Brand Store insights", coverageGranularity: "day", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.campaigns, label: "SP campaigns", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.adgroups, label: "SP ad groups", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.placements, label: "SP placements", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.advertisedProducts, label: "SP advertised products", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.purchasedProducts, label: "SP purchased products", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.searchTerms, label: "SP search terms", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.targeting, label: "SP targeting", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "ads", tableName: TABLES.spGrossAndInvalids, label: "SP gross and invalid traffic", coverageGranularity: "day", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sb_ads", tableName: TABLES.sbCampaigns, label: "SB campaigns", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sb_ads", tableName: TABLES.sbAds, label: "SB ads", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sb_ads", tableName: TABLES.sbSearchTerms, label: "SB search terms", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sb_ads", tableName: TABLES.sbTargeting, label: "SB targeting", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sb_ads", tableName: TABLES.sbPurchasedProducts, label: "SB purchased products", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sb_ads", tableName: TABLES.sbGrossAndInvalids, label: "SB gross and invalid traffic", coverageGranularity: "day", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sd_ads", tableName: TABLES.sdCampaigns, label: "SD campaigns", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sd_ads", tableName: TABLES.sdAdvertisedProducts, label: "SD advertised products", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sd_ads", tableName: TABLES.sdTargeting, label: "SD targeting", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sd_ads", tableName: TABLES.sdPurchasedProducts, label: "SD purchased products", coverageGranularity: "day", required: true, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "sd_ads", tableName: TABLES.sdGrossAndInvalids, label: "SD gross and invalid traffic", coverageGranularity: "day", required: false, expectedLagDays: ADS_DAILY_LAG_DAYS, lookbackDays: ADS_LOOKBACK_DAYS },
+  { syncMode: "business", tableName: TABLES.salesAndTraffic, label: "Sales and traffic", coverageGranularity: "day", required: true, expectedLagDays: SP_DAILY_LAG_DAYS, lookbackDays: SP_LOOKBACK_DAYS },
+  { syncMode: "inventory", tableName: TABLES.inventoryLedger, label: "Inventory ledger", coverageGranularity: "day", required: true, expectedLagDays: SP_DAILY_LAG_DAYS, lookbackDays: SP_LOOKBACK_DAYS },
+  { syncMode: "returns", tableName: TABLES.returns, label: "FBA returns", coverageGranularity: "day", required: true, expectedLagDays: 2, lookbackDays: 30 },
+  { syncMode: "reimbursements", tableName: TABLES.reimbursements, label: "FBA reimbursements", coverageGranularity: "day", required: true, expectedLagDays: 2, lookbackDays: 14 },
+  { syncMode: "order_metrics", tableName: TABLES.orderMetrics, label: "Order metrics", coverageGranularity: "snapshot", required: true, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "sqp", tableName: TABLES.sqp, label: "Search Query Performance", coverageGranularity: "week", required: true, expectedLagDays: WEEKLY_LAG_DAYS, lookbackDays: 35 },
+  { syncMode: "brand_metrics", tableName: TABLES.brandMetrics, label: "Brand Metrics", coverageGranularity: "week", required: false, expectedLagDays: WEEKLY_LAG_DAYS, lookbackDays: 35 },
+  { syncMode: "ba_search_terms", tableName: TABLES.baSearchTerms, label: "Brand Analytics search terms", coverageGranularity: "week", required: false, expectedLagDays: WEEKLY_LAG_DAYS, lookbackDays: 35 },
+  { syncMode: "ba_market_basket", tableName: TABLES.baMarketBasket, label: "Brand Analytics market basket", coverageGranularity: "week", required: false, expectedLagDays: WEEKLY_LAG_DAYS, lookbackDays: 35 },
+  { syncMode: "ba_repeat_purchase", tableName: TABLES.baRepeatPurchase, label: "Brand Analytics repeat purchase", coverageGranularity: "week", required: false, expectedLagDays: WEEKLY_LAG_DAYS, lookbackDays: 35 },
+  { syncMode: "ba_search_catalog", tableName: TABLES.baSearchCatalog, label: "Brand Analytics search catalog", coverageGranularity: "week", required: false, expectedLagDays: WEEKLY_LAG_DAYS, lookbackDays: 35 },
+  { syncMode: "inventory", tableName: TABLES.fbaInventory, label: "FBA inventory snapshot", coverageGranularity: "snapshot", required: true, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "inventory", tableName: TABLES.inventoryHealth, label: "Inventory health snapshot", coverageGranularity: "snapshot", required: true, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "listings", tableName: TABLES.activeListings, label: "Active listings snapshot", coverageGranularity: "snapshot", required: true, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "suppressed_listings", tableName: TABLES.suppressedListings, label: "Suppressed listings snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "awd", tableName: TABLES.awdInventory, label: "AWD inventory snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: SNAPSHOT_FRESHNESS_HOURS },
+  { syncMode: "fba_inbound", tableName: TABLES.fbaInboundShipments, label: "FBA inbound shipments", coverageGranularity: "snapshot", required: false, freshnessHours: 36 },
+  { syncMode: "fees", tableName: TABLES.referralFees, label: "Referral fees snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: 168 },
+  { syncMode: "fees", tableName: TABLES.fbaStorageFeeCharges, label: "FBA storage fee charges", coverageGranularity: "snapshot", required: false, freshnessHours: 168 },
+  { syncMode: "fees", tableName: TABLES.fbaLongTermStorageFeeCharges, label: "FBA long-term storage fee charges", coverageGranularity: "day", required: false, expectedLagDays: 35, lookbackDays: 45 },
+  { syncMode: "catalog", tableName: TABLES.catalogItems, label: "Catalog snapshot", coverageGranularity: "snapshot", required: true, freshnessHours: 48 },
+  { syncMode: "listing_quality", tableName: TABLES.listingQuality, label: "Listing quality snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: 192 },
+  { syncMode: "pricing", tableName: TABLES.pricingSnapshots, label: "Pricing snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: 48 },
+  { syncMode: "replenishment", tableName: TABLES.replenishmentOffers, label: "Replenishment offers snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: 48 },
+  { syncMode: "customer_feedback", tableName: TABLES.customerFeedbackSnapshots, label: "Customer Feedback snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: 192 },
+  { syncMode: "keyword_rank", tableName: TABLES.keywordRanks, label: "Keyword rank snapshot", coverageGranularity: "snapshot", required: false, freshnessHours: 192 },
+  { syncMode: "settlements", tableName: TABLES.settlements, label: "Settlements reports", coverageGranularity: "event", required: true, freshnessHours: 72 },
+  { syncMode: "financial_events", tableName: TABLES.financialEvents, label: "Financial events", coverageGranularity: "event", required: true, freshnessHours: 36 }
+];
+var MAX_REPORT_SECTIONS = 12;
+var MAX_REPORT_KPIS = 12;
+var MAX_REPORT_TABLE_ROWS = 250;
+var MAX_REPORT_CHART_ROWS = 120;
+var MAX_REPORT_CHART_SERIES = 6;
+var MAX_REPORT_COLUMNS = 12;
+var MAX_REPORT_SPEC_BYTES = 512 * 1024;
+var KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/;
+var ANCHOR_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]{0,79}$/;
+var shortText = (max) => z3.string().trim().min(1).max(max);
+var optionalText = (max) => z3.preprocess(
+  (value) => value === null || value === "" ? void 0 : value,
+  z3.string().trim().min(1).max(max).optional()
+);
+var reportKeySchema = z3.string().regex(KEY_PATTERN, "Use letters, numbers, and underscores; start with a letter or underscore").describe("Row key used by table columns and chart axes");
+var reportCellValueSchema = z3.union([
+  z3.string().max(1e3),
+  z3.number().finite(),
+  z3.boolean(),
+  z3.null()
+]);
+var reportColumnSchema = z3.object({
+  key: reportKeySchema,
+  label: shortText(80),
+  type: z3.enum(["text", "number", "currency", "percent", "date", "boolean", "image"]).default("text")
+}).strict();
+var baseSectionSchema = z3.object({
+  id: z3.string().regex(ANCHOR_PATTERN, "Use letters, numbers, dashes, and underscores; start with a letter").optional(),
+  title: optionalText(120),
+  description: optionalText(500)
+}).strict();
+var reportToneSchema = z3.enum(["neutral", "info", "good", "warning", "bad"]);
+var reportKpiSchema = z3.object({
+  label: shortText(80),
+  value: z3.union([z3.string().max(200), z3.number().finite()]),
+  unit: optionalText(24),
+  change: optionalText(120),
+  tone: reportToneSchema.default("neutral")
+}).strict();
+var reportKpiGridSectionSchema = baseSectionSchema.extend({
+  type: z3.literal("kpi_grid"),
+  kpis: z3.array(reportKpiSchema).min(1).max(MAX_REPORT_KPIS)
+});
+var tableRowsSchema = z3.array(z3.record(reportCellValueSchema)).max(MAX_REPORT_TABLE_ROWS);
+function isValidReportImageUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}
+var reportTableSectionSchema = baseSectionSchema.extend({
+  type: z3.literal("table"),
+  columns: z3.array(reportColumnSchema).min(1).max(MAX_REPORT_COLUMNS),
+  rows: tableRowsSchema,
+  total_rows: z3.number().int().nonnegative().optional(),
+  truncated: z3.boolean().default(false)
+}).superRefine((section, ctx) => {
+  const columnKeys = section.columns.map((column) => column.key);
+  const uniqueKeys = new Set(columnKeys);
+  if (uniqueKeys.size !== columnKeys.length) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["columns"],
+      message: "Column keys must be unique"
+    });
+  }
+  for (const [rowIndex, row] of section.rows.entries()) {
+    for (const key of Object.keys(row)) {
+      if (!uniqueKeys.has(key)) {
+        ctx.addIssue({
+          code: z3.ZodIssueCode.custom,
+          path: ["rows", rowIndex, key],
+          message: `Unknown table column key: ${key}`
+        });
+      }
+    }
+  }
+  const imageKeys = new Set(section.columns.filter((column) => column.type === "image").map((column) => column.key));
+  for (const [rowIndex, row] of section.rows.entries()) {
+    for (const key of imageKeys) {
+      const value = row[key];
+      if (value === void 0 || value === null) continue;
+      if (typeof value !== "string" || !isValidReportImageUrl(value)) {
+        ctx.addIssue({
+          code: z3.ZodIssueCode.custom,
+          path: ["rows", rowIndex, key],
+          message: "Image columns must contain HTTPS image URLs or null"
+        });
+      }
+    }
+  }
+  if (section.total_rows !== void 0 && section.total_rows < section.rows.length) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["total_rows"],
+      message: "total_rows must be greater than or equal to the rendered row count"
+    });
+  }
+});
+var chartRowsSchema = z3.array(z3.record(reportCellValueSchema)).min(1).max(MAX_REPORT_CHART_ROWS);
+var reportChartSeriesSchema = z3.object({
+  key: reportKeySchema,
+  label: shortText(80),
+  tone: reportToneSchema.optional()
+}).strict();
+var chartBaseSectionSchema = baseSectionSchema.extend({
+  x_key: reportKeySchema,
+  y_key: reportKeySchema.optional(),
+  series: z3.array(reportChartSeriesSchema).min(1).max(MAX_REPORT_CHART_SERIES).optional(),
+  x_label: optionalText(80),
+  y_label: optionalText(80),
+  value_type: z3.enum(["number", "currency", "percent"]).default("number"),
+  stacked: z3.boolean().default(false),
+  rows: chartRowsSchema
+});
+function validateChartRows(section, ctx) {
+  const series = section.series ?? (section.y_key ? [{ key: section.y_key, label: section.y_label ?? section.y_key }] : []);
+  if (series.length === 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["y_key"],
+      message: "Provide y_key or at least one series entry"
+    });
+  }
+  const seriesKeys = series.map((item) => item.key);
+  if (new Set(seriesKeys).size !== seriesKeys.length) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: ["series"],
+      message: "Series keys must be unique"
+    });
+  }
+  for (const [rowIndex, row] of section.rows.entries()) {
+    if (!(section.x_key in row)) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        path: ["rows", rowIndex, section.x_key],
+        message: `Missing x_key value: ${section.x_key}`
+      });
+    }
+    for (const item of series) {
+      if (!(item.key in row)) {
+        ctx.addIssue({
+          code: z3.ZodIssueCode.custom,
+          path: ["rows", rowIndex, item.key],
+          message: `Missing chart series value: ${item.key}`
+        });
+        continue;
+      }
+      if (typeof row[item.key] !== "number") {
+        ctx.addIssue({
+          code: z3.ZodIssueCode.custom,
+          path: ["rows", rowIndex, item.key],
+          message: `Chart series must reference numeric values: ${item.key}`
+        });
+      }
+    }
+  }
+}
+var reportBarChartSectionSchema = chartBaseSectionSchema.extend({
+  type: z3.literal("bar_chart")
+}).superRefine(validateChartRows);
+var reportLineChartSectionSchema = chartBaseSectionSchema.extend({
+  type: z3.literal("line_chart")
+}).superRefine(validateChartRows);
+var reportNoteSectionSchema = baseSectionSchema.extend({
+  type: z3.literal("note"),
+  body: shortText(2e3),
+  tone: reportToneSchema.default("neutral")
+});
+var reportSectionSchema = z3.union([
+  reportKpiGridSectionSchema,
+  reportTableSectionSchema,
+  reportBarChartSectionSchema,
+  reportLineChartSectionSchema,
+  reportNoteSectionSchema
+]);
+var reportSpecV1Schema = z3.object({
+  title: shortText(140),
+  summary: optionalText(1e3),
+  source: optionalText(500),
+  sections: z3.array(reportSectionSchema).min(1).max(MAX_REPORT_SECTIONS)
+}).strict().superRefine((spec, ctx) => {
+  const bytes = Buffer.byteLength(JSON.stringify(spec), "utf8");
+  if (bytes > MAX_REPORT_SPEC_BYTES) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      path: [],
+      message: `Report spec exceeds ${MAX_REPORT_SPEC_BYTES} bytes`
+    });
+  }
+});
+var CURRENCY_MONEY_POLICIES = Object.freeze({
+  USD: { currencyCode: "USD", minorUnit: 2, defaultDisplayLocale: "en-US", minBid: 0.02, maxBid: 100, maxPrice: 1e4 },
+  CAD: { currencyCode: "CAD", minorUnit: 2, defaultDisplayLocale: "en-CA", minBid: 0.02, maxBid: 100, maxPrice: 1e4 },
+  GBP: { currencyCode: "GBP", minorUnit: 2, defaultDisplayLocale: "en-GB", minBid: 0.02, maxBid: 100, maxPrice: 1e4 },
+  EUR: { currencyCode: "EUR", minorUnit: 2, defaultDisplayLocale: "de-DE", minBid: 0.02, maxBid: 100, maxPrice: 1e4 },
+  MXN: { currencyCode: "MXN", minorUnit: 2, defaultDisplayLocale: "es-MX", minBid: 0.1, maxBid: 2e3, maxPrice: 2e5 },
+  BRL: { currencyCode: "BRL", minorUnit: 2, defaultDisplayLocale: "pt-BR", minBid: 0.05, maxBid: 500, maxPrice: 5e4 },
+  SEK: { currencyCode: "SEK", minorUnit: 2, defaultDisplayLocale: "sv-SE", minBid: 0.1, maxBid: 1e3, maxPrice: 1e5 },
+  ZAR: { currencyCode: "ZAR", minorUnit: 2, defaultDisplayLocale: "en-ZA", minBid: 0.1, maxBid: 1500, maxPrice: 15e4 },
+  PLN: { currencyCode: "PLN", minorUnit: 2, defaultDisplayLocale: "pl-PL", minBid: 0.05, maxBid: 400, maxPrice: 4e4 },
+  EGP: { currencyCode: "EGP", minorUnit: 2, defaultDisplayLocale: "ar-EG", minBid: 0.5, maxBid: 3e3, maxPrice: 3e5 },
+  TRY: { currencyCode: "TRY", minorUnit: 2, defaultDisplayLocale: "tr-TR", minBid: 0.1, maxBid: 2e3, maxPrice: 2e5 },
+  AED: { currencyCode: "AED", minorUnit: 2, defaultDisplayLocale: "ar-AE", minBid: 0.1, maxBid: 350, maxPrice: 35e3 },
+  INR: { currencyCode: "INR", minorUnit: 2, defaultDisplayLocale: "en-IN", minBid: 1, maxBid: 5e3, maxPrice: 5e5 },
+  SGD: { currencyCode: "SGD", minorUnit: 2, defaultDisplayLocale: "en-SG", minBid: 0.02, maxBid: 150, maxPrice: 15e3 },
+  JPY: { currencyCode: "JPY", minorUnit: 0, defaultDisplayLocale: "ja-JP", minBid: 2, maxBid: 1e4, maxPrice: 1e6 },
+  AUD: { currencyCode: "AUD", minorUnit: 2, defaultDisplayLocale: "en-AU", minBid: 0.02, maxBid: 150, maxPrice: 15e3 },
+  SAR: { currencyCode: "SAR", minorUnit: 2, defaultDisplayLocale: "ar-SA", minBid: 0.1, maxBid: 350, maxPrice: 35e3 }
+});
+function fallbackMoneyPolicyForKnownCurrency(currencyCode) {
+  return {
+    currencyCode,
+    minorUnit: 2,
+    defaultDisplayLocale: "en",
+    minBid: 0.02,
+    maxBid: 100,
+    maxPrice: 1e4
+  };
+}
+function getMarketplaceMoneyPolicyForDefinition(marketplace) {
+  return CURRENCY_MONEY_POLICIES[marketplace.currencyCode] ?? fallbackMoneyPolicyForKnownCurrency(marketplace.currencyCode);
+}
+var CUSTOMER_FEEDBACK_MARKETPLACE_IDS = [...CUSTOMER_FEEDBACK_SUPPORTED_MARKETPLACE_IDS];
+var ADS_BRAND_METRICS_MARKETPLACE_IDS = [...ADS_BRAND_METRICS_SUPPORTED_MARKETPLACE_IDS];
+var ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_MARKETPLACE_IDS = [
+  ...ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_SUPPORTED_MARKETPLACE_IDS
+];
+var ADS_SPONSORED_PRODUCTS_BID_RECOMMENDATION_MARKETPLACE_IDS = [
+  ...ADS_SPONSORED_PRODUCTS_BID_RECOMMENDATION_SUPPORTED_MARKETPLACE_IDS
+];
+var ADS_SPONSORED_PRODUCTS_BUDGET_RECOMMENDATION_MARKETPLACE_IDS = [
+  ...ADS_SPONSORED_PRODUCTS_BUDGET_RECOMMENDATION_SUPPORTED_MARKETPLACE_IDS
+];
+var AWD_MARKETPLACE_IDS = [...AWD_SUPPORTED_MARKETPLACE_IDS];
+var BRAND_ANALYTICS_REPORT_MARKETPLACE_IDS = [...BRAND_ANALYTICS_REPORT_SUPPORTED_MARKETPLACE_IDS];
+var FBA_INVENTORY_PLANNING_MARKETPLACE_IDS = [...FBA_INVENTORY_PLANNING_SUPPORTED_MARKETPLACE_IDS];
+var FULFILLMENT_INBOUND_MARKETPLACE_IDS = [...FULFILLMENT_INBOUND_SUPPORTED_MARKETPLACE_IDS];
+var DEFAULT_SUPPORT_RULE = Object.freeze({ support: "all" });
+var TOOL_MARKETPLACE_SUPPORT_DECLARED_TOOL_NAMES = [
+  "get_campaign_performance",
+  "get_campaign_snapshots",
+  "get_adgroup_performance",
+  "get_keyword_performance",
+  "get_product_performance",
+  "get_purchased_products",
+  "get_search_terms",
+  "get_placement_breakdown",
+  "get_sb_campaign_performance",
+  "get_sd_campaign_performance",
+  "get_sponsored_ads_report",
+  "get_dsp_performance",
+  "get_dsp_advertisers_live",
+  "get_dsp_entities_live",
+  "get_store_performance",
+  "get_portfolio_performance",
+  "get_sales_and_traffic",
+  "get_tacos",
+  "get_ads_change_history",
+  "get_search_query_performance",
+  "get_repeat_purchase_behavior",
+  "get_search_query_ad_coverage",
+  "diagnose_performance",
+  "get_sp_entities_live",
+  "get_sponsored_ads_entities_live",
+  "get_sp_targeting_options",
+  "get_sponsored_ads_targeting_options",
+  "create_sb_campaigns",
+  "update_sb_campaign_budget",
+  "update_sb_campaign_state",
+  "archive_sb_campaigns",
+  "create_sb_ad_groups",
+  "update_sb_ad_group_state",
+  "archive_sb_ad_groups",
+  "create_sb_ads",
+  "update_sb_ad_state",
+  "archive_sb_ads",
+  "create_sb_targets",
+  "update_sb_target_bids",
+  "update_sb_target_state",
+  "archive_sb_targets",
+  "create_sb_negative_targets",
+  "update_sb_negative_target_state",
+  "archive_sb_negative_targets",
+  "update_keyword_bids",
+  "update_target_bids",
+  "update_keyword_state",
+  "archive_keywords",
+  "update_adgroup_bid",
+  "update_campaign_bidding",
+  "update_campaign_budget",
+  "update_campaign_state",
+  "archive_campaigns",
+  "create_sd_campaigns",
+  "update_sd_campaign_budget",
+  "update_sd_campaign_state",
+  "archive_sd_campaigns",
+  "create_sd_ad_groups",
+  "update_sd_ad_group_bid",
+  "update_sd_ad_group_state",
+  "archive_sd_ad_groups",
+  "create_sd_product_ads",
+  "update_sd_product_ad_state",
+  "archive_sd_product_ads",
+  "create_sd_targets",
+  "update_sd_target_bids",
+  "update_sd_target_state",
+  "archive_sd_targets",
+  "create_sd_negative_targets",
+  "update_sd_negative_target_state",
+  "archive_sd_negative_targets",
+  "update_campaign_audience_bid_adjustment",
+  "create_keywords",
+  "create_negative_keywords",
+  "create_sp_campaigns",
+  "create_sp_ad_groups",
+  "create_sp_product_ads",
+  "update_sp_ad_entities",
+  "create_sp_targets",
+  "update_sp_target_state",
+  "archive_sp_targets",
+  "create_sp_negative_targets",
+  "update_sp_negative_keyword_state",
+  "archive_sp_negative_keywords",
+  "update_sp_negative_target_state",
+  "archive_sp_negative_targets",
+  "get_bid_recommendations",
+  "get_budget_recommendations",
+  "get_budget_pacing",
+  "get_ad_eligibility",
+  "get_brand_health",
+  "get_share_of_voice",
+  "get_attribution_performance",
+  "get_audience_segments",
+  "get_fba_inventory",
+  "get_inventory_health",
+  "get_fba_storage_fees",
+  "get_inventory_movements",
+  "get_inventory_by_fulfillment_center",
+  "get_awd_inventory",
+  "get_awd_shipments",
+  "get_awd_shipment_items",
+  "get_inbound_shipments",
+  "get_shipment_receiving_status",
+  "get_sales_velocity",
+  "get_listing_registry",
+  "get_suppressed_listings",
+  "get_days_of_cover",
+  "get_todays_sales",
+  "get_orders",
+  "get_order_details",
+  "get_returns",
+  "get_reimbursements",
+  "get_seasonality_index",
+  "get_sales_summary",
+  "get_inventory_risk_triage",
+  "get_current_rank",
+  "get_buybox_status",
+  "get_competitive_pricing",
+  "get_offer_listings",
+  "get_subscribe_and_save",
+  "get_fba_eligibility",
+  "get_listing_restrictions",
+  "get_financial_events",
+  "get_profitability_review",
+  "get_payment_transactions",
+  "get_settlement_economics",
+  "get_product_details",
+  "get_sales_ranks",
+  "get_aplus_status",
+  "get_variations",
+  "get_product_reviews",
+  "get_review_trends",
+  "get_listing_quality",
+  "get_catalog_cleanup",
+  "create_listing",
+  "update_listing",
+  "update_price",
+  "update_inventory_quantity",
+  "get_keyword_ranks",
+  "get_shipping_preview",
+  "get_mcf_orders",
+  "create_mcf_order",
+  "manage_returns",
+  "get_account_data_tour",
+  "submit_conversation_feedback",
+  "get_account_info",
+  "get_action_history"
+];
+var ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_TOOL_NAMES = [
+  "get_sp_entities_live",
+  "get_sp_targeting_options",
+  "update_keyword_bids",
+  "update_target_bids",
+  "update_keyword_state",
+  "archive_keywords",
+  "update_adgroup_bid",
+  "update_campaign_bidding",
+  "update_campaign_budget",
+  "update_campaign_state",
+  "archive_campaigns",
+  "update_campaign_audience_bid_adjustment",
+  "create_keywords",
+  "create_negative_keywords",
+  "create_sp_campaigns",
+  "create_sp_ad_groups",
+  "create_sp_product_ads",
+  "update_sp_ad_entities",
+  "create_sp_targets",
+  "update_sp_target_state",
+  "archive_sp_targets",
+  "create_sp_negative_targets",
+  "update_sp_negative_keyword_state",
+  "archive_sp_negative_keywords",
+  "update_sp_negative_target_state",
+  "archive_sp_negative_targets"
+];
+var ADS_SPONSORED_BRANDS_CAMPAIGN_MANAGEMENT_TOOL_NAMES = [
+  "create_sb_campaigns",
+  "update_sb_campaign_budget",
+  "update_sb_campaign_state",
+  "archive_sb_campaigns",
+  "create_sb_ad_groups",
+  "update_sb_ad_group_state",
+  "archive_sb_ad_groups",
+  "create_sb_ads",
+  "update_sb_ad_state",
+  "archive_sb_ads",
+  "create_sb_targets",
+  "update_sb_target_bids",
+  "update_sb_target_state",
+  "archive_sb_targets",
+  "create_sb_negative_targets",
+  "update_sb_negative_target_state",
+  "archive_sb_negative_targets"
+];
+var BRAND_ANALYTICS_REPORT_TOOL_NAMES = [
+  "get_search_query_performance",
+  "get_repeat_purchase_behavior",
+  "get_search_query_ad_coverage",
+  "get_keyword_ranks"
+];
+var ADS_BRAND_METRICS_TOOL_NAMES = [
+  "get_brand_health",
+  "get_share_of_voice"
+];
+var AWD_TOOL_NAMES = [
+  "get_awd_inventory",
+  "get_awd_shipments",
+  "get_awd_shipment_items"
+];
+var FULFILLMENT_INBOUND_TOOL_NAMES = [
+  "get_inbound_shipments",
+  "get_shipment_receiving_status"
+];
+function assignMarketplaceRule(rules, toolNames, rule) {
+  for (const toolName of toolNames) {
+    rules[toolName] = rule;
+  }
+}
+function buildMarketplaceSupportRules() {
+  const rules = {};
+  for (const toolName of TOOL_MARKETPLACE_SUPPORT_DECLARED_TOOL_NAMES) {
+    rules[toolName] = DEFAULT_SUPPORT_RULE;
+  }
+  assignMarketplaceRule(rules, ["get_product_reviews", "get_review_trends"], {
+    support: "marketplaces",
+    marketplaceIds: CUSTOMER_FEEDBACK_MARKETPLACE_IDS,
+    capability: "sp_api_customer_feedback",
+    source: "Amazon Customer Feedback API marketplace validation",
+    note: "Amazon's Customer Feedback API currently accepts US, UK, DE, ES, FR, IT, and JP marketplace IDs."
+  });
+  assignMarketplaceRule(rules, ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_TOOL_NAMES, {
+    support: "marketplaces",
+    marketplaceIds: ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_MARKETPLACE_IDS,
+    capability: "amazon_ads_sp_campaign_management",
+    source: "Amazon Ads Sponsored Products feature availability by marketplace",
+    note: "Amazon Ads documents Sponsored Products Campaign Management and Product Recommendations for US, CA, MX, BR, DE, ES, FR, IT, UK, NL, SE, TR, PL, BE, AE, EG, SA, JP, IN, AU, SG, and ZA."
+  });
+  assignMarketplaceRule(rules, ADS_SPONSORED_BRANDS_CAMPAIGN_MANAGEMENT_TOOL_NAMES, {
+    support: "marketplaces",
+    marketplaceIds: ADS_SPONSORED_PRODUCTS_CAMPAIGN_MANAGEMENT_MARKETPLACE_IDS,
+    capability: "amazon_ads_sb_campaign_management",
+    source: "Amazon Ads Common Campaign Management / Sponsored Brands target write availability",
+    note: "Uses the conservative Ads campaign-management marketplace allowlist until a separate Sponsored Brands Common Campaign Management marketplace matrix is pinned."
+  });
+  rules.get_bid_recommendations = {
+    support: "marketplaces",
+    marketplaceIds: ADS_SPONSORED_PRODUCTS_BID_RECOMMENDATION_MARKETPLACE_IDS,
+    capability: "amazon_ads_sp_theme_based_bid_suggestions",
+    source: "Amazon Ads Sponsored Products feature availability by marketplace",
+    note: "Amazon Ads documents Theme-based bid suggestions for US, CA, DE, ES, FR, UK, JP, and IN."
+  };
+  rules.get_budget_recommendations = {
+    support: "marketplaces",
+    marketplaceIds: ADS_SPONSORED_PRODUCTS_BUDGET_RECOMMENDATION_MARKETPLACE_IDS,
+    capability: "amazon_ads_sp_budget_recommendations",
+    source: "Amazon Ads Sponsored Products feature availability by marketplace",
+    note: "Amazon Ads documents budget recommendations for US, CA, MX, DE, ES, FR, UK, IT, JP, IN, AU, and AE."
+  };
+  assignMarketplaceRule(rules, ADS_BRAND_METRICS_TOOL_NAMES, {
+    support: "marketplaces",
+    marketplaceIds: ADS_BRAND_METRICS_MARKETPLACE_IDS,
+    capability: "amazon_ads_brand_metrics",
+    source: "Amazon Ads Brand Metrics API open beta eligibility",
+    note: "Amazon Ads documents Brand Metrics API eligibility for US, CA, MX, UK, DE, FR, IN, IT, ES, JP, and AU."
+  });
+  assignMarketplaceRule(rules, BRAND_ANALYTICS_REPORT_TOOL_NAMES, {
+    support: "marketplaces",
+    marketplaceIds: BRAND_ANALYTICS_REPORT_MARKETPLACE_IDS,
+    capability: "sp_api_brand_analytics_reports",
+    source: "Amazon SP-API Analytics report type marketplace availability",
+    note: "Amazon documents SQP/Search Catalog/Market Basket/Repeat Purchase reports for NA all marketplaces, FE all marketplaces, and ES, UK, FR, NL, DE, IT, SE, TR, SA, AE, and IN in the EU endpoint region."
+  });
+  assignMarketplaceRule(rules, AWD_TOOL_NAMES, {
+    support: "marketplaces",
+    marketplaceIds: AWD_MARKETPLACE_IDS,
+    capability: "sp_api_awd",
+    source: "Amazon SP-API Amazon Warehousing and Distribution API marketplace availability",
+    note: "Amazon documents AWD v2024-05-09 as available in the US marketplace."
+  });
+  assignMarketplaceRule(rules, FULFILLMENT_INBOUND_TOOL_NAMES, {
+    support: "marketplaces",
+    marketplaceIds: FULFILLMENT_INBOUND_MARKETPLACE_IDS,
+    capability: "sp_api_fulfillment_inbound",
+    source: "Amazon SP-API Fulfillment Inbound API marketplace availability",
+    note: "Amazon documents Fulfillment Inbound shipment creation as supported in all marketplaces except Brazil."
+  });
+  rules.get_inventory_health = {
+    support: "marketplaces",
+    marketplaceIds: FBA_INVENTORY_PLANNING_MARKETPLACE_IDS,
+    capability: "sp_api_fba_inventory_planning_report",
+    source: "Amazon SP-API FBA Manage Inventory Health report marketplace availability",
+    note: "Amazon documents GET_FBA_INVENTORY_PLANNING_DATA as unavailable in the NL, PL, SE, and BE marketplaces."
+  };
+  return rules;
+}
+var TOOL_MARKETPLACE_SUPPORT = Object.freeze(
+  buildMarketplaceSupportRules()
+);
+var DOMAIN_BY_TOOL = /* @__PURE__ */ new Map();
+var WRITE_TOOL_NAMES = /* @__PURE__ */ new Set();
+for (const domain of TOOL_DOMAINS) {
+  for (const tool of domain.tools) {
+    DOMAIN_BY_TOOL.set(tool.name, domain.serverDomain);
+    if (tool.write) WRITE_TOOL_NAMES.add(tool.name);
+  }
+}
+for (const tool of UTILITY_TOOLS) {
+  DOMAIN_BY_TOOL.set(tool.name, "utility");
+  if (tool.write) WRITE_TOOL_NAMES.add(tool.name);
+}
+var MARKETPLACE_CAPABILITY_POLICY_VERSION = "marketplace-capabilities-v2-enabled-2026-05-26";
+var US_WRITE_EVIDENCE_VERSION = "phase1-us-write-baseline";
+var CANADA_CAPABILITY_EVIDENCE_VERSION = "marketplace-capabilities-v2-ca-enabled-2026-05-26";
+var CANADA_BASE_EVIDENCE_IDS = [
+  "ca.registry-facts.v1",
+  "ca.seller-central-url.v1",
+  "ca.timezone-source.v1",
+  "ca.promotion-effects.v1"
+];
+var CANADA_ADS_ENABLED_EVIDENCE_IDS = ["ca.ads-write-enabled.repo-contract.v1"];
+var CANADA_CATALOG_ENABLED_EVIDENCE_IDS = [
+  "ca.catalog-update-price-cad-preview.repo-proof.v1",
+  "ca.catalog-write-enabled.repo-contract.v1"
+];
+var CANADA_FULFILLMENT_ENABLED_EVIDENCE_IDS = ["ca.fulfillment-write-enabled.repo-contract.v1"];
+function policyKey(marketplaceId, toolFamily) {
+  return `${marketplaceId}:${toolFamily}`;
+}
+var MARKETPLACE_CAPABILITY_POLICIES = [
+  {
+    marketplaceId: DEFAULT_MARKETPLACE_ID,
+    toolFamily: "ads_write",
+    requiredConnection: "ads",
+    evidenceVersion: US_WRITE_EVIDENCE_VERSION,
+    evidenceIds: ["existing-us-ads-write-contract-tests"],
+    capabilityRolloutTrack: "foundation",
+    evidenceStatus: "recorded",
+    requiredEvidence: ["existing_foundation_behavior_preserved"],
+    stages: { preview: "enabled", write: "enabled" },
+    notes: "Existing US Ads write behavior remains enabled while v2 policy is introduced."
+  },
+  {
+    marketplaceId: DEFAULT_MARKETPLACE_ID,
+    toolFamily: "catalog_write",
+    requiredConnection: "sp_api",
+    evidenceVersion: US_WRITE_EVIDENCE_VERSION,
+    evidenceIds: ["existing-us-catalog-write-contract-tests"],
+    capabilityRolloutTrack: "foundation",
+    evidenceStatus: "recorded",
+    requiredEvidence: ["existing_foundation_behavior_preserved"],
+    stages: { preview: "enabled", write: "enabled" },
+    notes: "Existing US catalog write behavior remains enabled while v2 policy is introduced."
+  },
+  {
+    marketplaceId: DEFAULT_MARKETPLACE_ID,
+    toolFamily: "fulfillment_write",
+    requiredConnection: "sp_api",
+    evidenceVersion: US_WRITE_EVIDENCE_VERSION,
+    evidenceIds: ["existing-us-fulfillment-write-contract-tests"],
+    capabilityRolloutTrack: "foundation",
+    evidenceStatus: "recorded",
+    requiredEvidence: ["existing_foundation_behavior_preserved"],
+    stages: { write: "enabled" },
+    notes: "Existing US fulfillment write behavior remains enabled while v2 policy is introduced."
+  },
+  {
+    marketplaceId: "A2EUQ1WTGCTBG2",
+    toolFamily: "ads_write",
+    requiredConnection: "ads",
+    evidenceVersion: CANADA_CAPABILITY_EVIDENCE_VERSION,
+    evidenceIds: [...CANADA_BASE_EVIDENCE_IDS, ...CANADA_ADS_ENABLED_EVIDENCE_IDS],
+    capabilityRolloutTrack: "enabled",
+    evidenceStatus: "recorded",
+    requiredEvidence: ["contract_tests_pass"],
+    stages: { preview: "enabled", write: "enabled" },
+    notes: "Canada Ads writes are enabled. Runtime write safety still requires scoped credentials without endpoint mismatch or tenant-key ambiguity."
+  },
+  {
+    marketplaceId: "A2EUQ1WTGCTBG2",
+    toolFamily: "catalog_write",
+    requiredConnection: "sp_api",
+    evidenceVersion: CANADA_CAPABILITY_EVIDENCE_VERSION,
+    evidenceIds: [...CANADA_BASE_EVIDENCE_IDS, ...CANADA_CATALOG_ENABLED_EVIDENCE_IDS],
+    capabilityRolloutTrack: "enabled",
+    evidenceStatus: "recorded",
+    requiredEvidence: ["contract_tests_pass", "currency_safe_previews_and_audits_verified"],
+    stages: { preview: "enabled", write: "enabled" },
+    notes: "Canada catalog previews and writes are enabled with CAD marketplace facts. Runtime write safety still requires scoped SP-API credentials without endpoint mismatch or tenant-key ambiguity."
+  },
+  {
+    marketplaceId: "A2EUQ1WTGCTBG2",
+    toolFamily: "fulfillment_write",
+    requiredConnection: "sp_api",
+    evidenceVersion: CANADA_CAPABILITY_EVIDENCE_VERSION,
+    evidenceIds: [...CANADA_BASE_EVIDENCE_IDS, ...CANADA_FULFILLMENT_ENABLED_EVIDENCE_IDS],
+    capabilityRolloutTrack: "enabled",
+    evidenceStatus: "recorded",
+    requiredEvidence: ["contract_tests_pass"],
+    stages: { write: "enabled" },
+    notes: "Canada fulfillment writes are enabled. Runtime write safety still requires scoped SP-API credentials without endpoint mismatch or tenant-key ambiguity."
+  }
+];
+var MARKETPLACE_CAPABILITY_POLICY_BY_KEY = new Map(
+  MARKETPLACE_CAPABILITY_POLICIES.map((policy) => [policyKey(policy.marketplaceId, policy.toolFamily), policy])
+);
+var MARKETPLACE_CAPABILITY_CAPSULES = MARKETPLACE_DEFINITIONS.map((marketplace) => {
+  const toolFamilies = MARKETPLACE_CAPABILITY_POLICIES.filter(
+    (policy) => policy.marketplaceId === marketplace.marketplaceId
+  );
+  const hasCandidateCapabilityPolicy = toolFamilies.some(
+    (policy) => policy.capabilityRolloutTrack === "v2_candidate"
+  );
+  const hasEnabledCapabilityPolicy = toolFamilies.some(
+    (policy) => policy.capabilityRolloutTrack === "enabled"
+  );
+  return {
+    marketplaceId: marketplace.marketplaceId,
+    capsuleVersion: MARKETPLACE_CAPABILITY_POLICY_VERSION,
+    base: marketplace,
+    money: getMarketplaceMoneyPolicyForDefinition(marketplace),
+    toolFamilies,
+    rolloutGates: hasCandidateCapabilityPolicy ? [
+      "registry_metadata_verified",
+      "contract_tests_pass",
+      "read_only_smoke_evidence_recorded",
+      "currency_safe_previews_and_audits_verified",
+      "write_evidence_recorded_before_promotion"
+    ] : hasEnabledCapabilityPolicy ? ["registry_metadata_verified", "contract_tests_pass", "runtime_write_guardrails_preserved"] : ["existing_foundation_behavior_preserved"]
+  };
+});
+var GLOBAL_MARKETPLACE_CAPABILITY_EVIDENCE_SCOPE = "global";
+var COMMON_MARKETPLACE_CAPABILITY_EVIDENCE_SCOPE = "common";
+var CANADA_MARKETPLACE_ID = "A2EUQ1WTGCTBG2";
+var MARKETPLACE_CAPABILITY_EVIDENCE_REGISTRY = [
+  {
+    id: "default-deny",
+    status: "recorded",
+    marketplaceId: GLOBAL_MARKETPLACE_CAPABILITY_EVIDENCE_SCOPE,
+    toolFamily: "all",
+    operation: "all",
+    sourceType: "repo_policy",
+    artifactPath: "packages/shared/src/marketplace-capabilities.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplace-capabilities.test.ts",
+      "packages/shared/src/marketplace-capabilities.contract.test.ts"
+    ],
+    summary: "Default-deny fallback evidence version for unknown marketplaces and marketplace/tool-family combinations without explicit policy rows.",
+    notes: "Recorded deny behavior only; this evidence record does not grant any marketplace capability."
+  },
+  {
+    id: "existing-us-ads-write-contract-tests",
+    status: "recorded",
+    marketplaceId: DEFAULT_MARKETPLACE_ID,
+    toolFamily: "ads_write",
+    operation: "write",
+    sourceType: "repo_contract_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: ["packages/shared/src/marketplace-capabilities.contract.test.ts"],
+    summary: "Existing US Ads write-family behavior is covered by shared marketplace capability tests while v2 policy is introduced."
+  },
+  {
+    id: "existing-us-catalog-write-contract-tests",
+    status: "recorded",
+    marketplaceId: DEFAULT_MARKETPLACE_ID,
+    toolFamily: "catalog_write",
+    operation: "write",
+    sourceType: "repo_contract_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: ["packages/shared/src/marketplace-capabilities.contract.test.ts"],
+    summary: "Existing US catalog write-family behavior is covered by shared marketplace capability tests while v2 policy is introduced."
+  },
+  {
+    id: "existing-us-fulfillment-write-contract-tests",
+    status: "recorded",
+    marketplaceId: DEFAULT_MARKETPLACE_ID,
+    toolFamily: "fulfillment_write",
+    operation: "write",
+    sourceType: "repo_contract_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: ["packages/shared/src/marketplace-capabilities.contract.test.ts"],
+    summary: "Existing US fulfillment write-family behavior is covered by shared marketplace capability tests while v2 policy is introduced."
+  },
+  {
+    id: "ca.registry-facts.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "all",
+    operation: "all",
+    sourceType: "repo_registry",
+    artifactPath: "packages/shared/src/marketplaces.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplaces.test.ts",
+      "docs/internal/runbooks/marketplace-capabilities-v2.md"
+    ],
+    summary: "Canada marketplace registry facts are code-owned: marketplace ID, country, domain, currency, reporting timezone, Seller Central host, SP-API endpoint, and Ads endpoint."
+  },
+  {
+    id: "ca.seller-central-url.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "all",
+    operation: "all",
+    sourceType: "repo_registry",
+    artifactPath: "packages/shared/src/marketplaces.ts",
+    supportingArtifactPaths: ["docs/internal/runbooks/marketplace-capabilities-v2.md"],
+    summary: "Canada Seller Central base URL is recorded as https://sellercentral.amazon.ca in the marketplace registry."
+  },
+  {
+    id: "ca.timezone-source.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "all",
+    operation: "all",
+    sourceType: "repo_registry",
+    artifactPath: "packages/shared/src/marketplaces.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplaces.test.ts",
+      "docs/internal/runbooks/marketplace-capabilities-v2.md"
+    ],
+    summary: "Canada default reporting timezone is recorded as America/Toronto and validated through shared marketplace registry tests."
+  },
+  {
+    id: "ca.promotion-effects.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "all",
+    operation: "all",
+    sourceType: "repo_policy",
+    artifactPath: "packages/shared/src/marketplace-capabilities.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplace-capabilities.test.ts",
+      "packages/shared/src/marketplace-capabilities.contract.test.ts",
+      "docs/internal/runbooks/marketplace-capabilities-v2.md"
+    ],
+    summary: "Canada policy effects are explicit: Canada Ads, catalog, and fulfillment write-family rows are enabled; UK, Saudi Arabia, unknown marketplaces, and unconfigured marketplace/tool-family combinations remain default-denied."
+  },
+  {
+    id: "ca.ads-write-enabled.repo-contract.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "ads_write",
+    operation: "write",
+    sourceType: "repo_contract_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplace-capabilities.contract.test.ts",
+      "packages/hosted-server/src/util/marketplace-write-safety.test.ts"
+    ],
+    summary: "Repo tests cover Canada Ads write-family policy as enabled with CAD marketplace facts, Ads connection requirements, and runtime endpoint/marketplace-scope write safety preserved."
+  },
+  {
+    id: "ca.catalog-write-enabled.repo-contract.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "catalog_write",
+    operation: "write",
+    sourceType: "repo_contract_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplace-capabilities.contract.test.ts",
+      "packages/hosted-server/src/util/marketplace-write-safety.test.ts",
+      "packages/hosted-server/src/tools/catalog/update-price.test.ts"
+    ],
+    summary: "Repo tests cover Canada catalog preview and write policy as enabled with CAD marketplace facts and runtime endpoint/marketplace-scope write safety preserved."
+  },
+  {
+    id: "ca.fulfillment-write-enabled.repo-contract.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "fulfillment_write",
+    operation: "write",
+    sourceType: "repo_contract_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplace-capabilities.contract.test.ts",
+      "packages/hosted-server/src/util/marketplace-write-safety.test.ts"
+    ],
+    summary: "Repo tests cover Canada fulfillment write-family policy as enabled with CAD marketplace facts, SP-API connection requirements, and runtime endpoint/marketplace-scope write safety preserved."
+  },
+  {
+    id: "ca.ads-readonly-smoke.pending",
+    status: "pending",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "ads_write",
+    operation: "read",
+    sourceType: "live_smoke",
+    artifactPath: "docs/internal/evidence/marketplace-capabilities/canada-ads-readonly-smoke-template.md",
+    supportingArtifactPaths: ["docs/internal/runbooks/marketplace-capabilities-v2.md"],
+    summary: "Controlled read-only Canada Ads smoke evidence is pending and has not been performed in this repo-only enablement change.",
+    notes: "Optional live evidence; requires explicit approval, controlled credentials, and no mutation calls before it can be changed to recorded."
+  },
+  {
+    id: "ca.spapi-readonly-smoke.pending",
+    status: "pending",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "all",
+    operation: "read",
+    sourceType: "live_smoke",
+    artifactPath: "docs/internal/evidence/marketplace-capabilities/canada-spapi-readonly-smoke-template.md",
+    supportingArtifactPaths: ["docs/internal/runbooks/marketplace-capabilities-v2.md"],
+    summary: "Controlled read-only Canada SP-API smoke evidence is pending and has not been performed in this repo-only enablement change.",
+    notes: "Optional live evidence; requires explicit approval, controlled credentials, and no mutation calls before it can be changed to recorded."
+  },
+  {
+    id: "ca.catalog-update-price-cad-preview.repo-proof.v1",
+    status: "recorded",
+    marketplaceId: CANADA_MARKETPLACE_ID,
+    toolFamily: "catalog_write",
+    operation: "preview",
+    sourceType: "repo_tool_test",
+    artifactPath: "packages/shared/src/marketplace-capabilities.test.ts",
+    supportingArtifactPaths: [
+      "packages/shared/src/marketplace-capabilities.contract.test.ts",
+      "packages/hosted-server/src/util/marketplace-write-safety.test.ts",
+      "packages/hosted-server/src/tools/catalog/update-price.test.ts",
+      "docs/internal/runbooks/marketplace-capabilities-v2.md"
+    ],
+    summary: "Repo tests prove Canada update_price validation preview is CAD-scoped and uses Canada marketplace facts while Canada catalog write-family policy is enabled."
+  }
+];
+var MARKETPLACE_CAPABILITY_EVIDENCE_BY_ID = new Map(
+  MARKETPLACE_CAPABILITY_EVIDENCE_REGISTRY.map((record) => [record.id, record])
+);
+function getMarketplaceCapabilityEvidenceRecord(id) {
+  return MARKETPLACE_CAPABILITY_EVIDENCE_BY_ID.get(id);
+}
+var MARKETPLACE_CAPABILITY_EVIDENCE_CAPTURE_SCHEMA_VERSION = "marketplace-capability-evidence-capture.v1";
+var MARKETPLACE_CAPABILITY_EVIDENCE_CAPTURE_STATUSES = ["example", "captured", "failed"];
+var MARKETPLACE_CAPABILITY_EVIDENCE_CAPTURE_SOURCE_TYPES = [
+  "ads_api_readonly_smoke",
+  "sp_api_readonly_smoke"
+];
+var READ_ONLY_HTTP_METHODS = ["GET", "HEAD", "OPTIONS"];
+var AMAZON_REGIONS = ["NA", "EU", "FE"];
+var API_SERVICES = ["ads", "sp_api"];
+var EVIDENCE_FACT_SOURCES = [
+  "response_body",
+  "response_header",
+  "request_context",
+  "amazon_marketplace_metadata",
+  "repo_registry_fallback",
+  "operator_observation"
+];
+var CAPTURED_AT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+var REPO_RELATIVE_PATH_PATTERN = /^(?!\/)(?![a-z][a-z\d+.-]*:)[\w./@-]+$/i;
+var REDACTION_PLACEHOLDER_PATTERN = /(?:\[(?:redacted|masked)\]|<(?:redacted|masked)>|\b(?:redacted|masked)(?:[_-][a-z0-9]+)*\b|\*{3,})/i;
+var REDACTED_PATH_SEGMENT = "[redacted-key]";
+var REDACTED_VALUE_SEGMENT = "[redacted-value]";
+var EXAMPLE_DOMAIN_PATTERN = /(?:^|\.)example\.(?:invalid|com|net|org)$/i;
+var BEARER_TOKEN_PATTERN = /\bBearer\s+([^\s"',;]+)/gi;
+var AUTHORIZATION_HEADER_PATTERN = /\bauthorization\b\s*[:=]\s*["']?(?:(?:Bearer|Basic|AWS4-HMAC-SHA256)\s+)?([^\s"',;]+)/gi;
+var SENSITIVE_ASSIGNMENT_PATTERN = /\b(?:access[_-]?token|refresh[_-]?token|id[_-]?token|client[_-]?secret|api[_-]?key)\b\s*[:=]\s*["']?([^\s"',;&]+)/gi;
+var AGENTCENTRAL_API_KEY_PATTERN = /\bac_(?:live|test|dev)_[A-Za-z0-9_-]{8,}\b/g;
+var AMAZON_TOKEN_PATTERN = /\bamz_[A-Za-z0-9_-]{8,}\b/gi;
+var AWS_ACCESS_KEY_PATTERN = /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g;
+var EMAIL_ADDRESS_PATTERN = /\b[A-Z0-9._%+-]+@([A-Z0-9.-]+\.[A-Z]{2,})\b/gi;
+var PHONE_NUMBER_PATTERN = /(?:\+?\d{1,3}[\s.-]*)?(?:\(\d{3}\)|\d{3})[\s.-]\d{3}[\s.-]\d{4}\b/g;
+var INTERNATIONAL_PHONE_NUMBER_PATTERN = /\+\d{10,15}\b/g;
+var LONG_KEY_LIKE_PATTERN = /(?<![A-Za-z0-9_+=/-])(?:[A-Za-z0-9_+=/-]{32,})(?![A-Za-z0-9_+=/-])/g;
+var httpsUrlSchema = z4.string().url().refine((value) => {
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}, "Expected an HTTPS URL");
+var capturedAtSchema = z4.string().regex(CAPTURED_AT_PATTERN, "Expected an ISO-8601 UTC timestamp, for example 2026-05-17T12:34:56.000Z").refine((value) => !Number.isNaN(Date.parse(value)), "Expected a parseable UTC timestamp");
+var registryEvidenceIdSchema = z4.string().min(1);
+var evidenceFactSchema = z4.object({
+  expected: z4.string().min(1),
+  observed: z4.string().min(1).nullable(),
+  source: z4.enum(EVIDENCE_FACT_SOURCES),
+  matchesExpected: z4.boolean(),
+  notes: z4.string().min(1).optional()
+}).strict();
+var readOnlyCallSummarySchema = z4.object({
+  operationName: z4.string().min(1),
+  method: z4.enum(READ_ONLY_HTTP_METHODS),
+  endpointPath: z4.string().min(1),
+  redactedUrl: z4.string().min(1),
+  responseStatus: z4.number().int().min(100).max(599).optional(),
+  returnedFieldNames: z4.array(z4.string().min(1)).min(1),
+  redactedResponseShape: z4.record(z4.unknown()).optional(),
+  notes: z4.string().min(1).optional()
+}).strict();
+var noMutationAttestationSchema = z4.object({
+  requestSetReadOnly: z4.literal(true),
+  noMutationEndpointsCalled: z4.literal(true),
+  noMcpWriteToolsRun: z4.literal(true),
+  noSyncsTriggered: z4.literal(true),
+  noApiKeyMutations: z4.literal(true),
+  noDeployments: z4.literal(true),
+  noProductionOrCustomerDataMutated: z4.literal(true),
+  statement: z4.string().min(1)
+}).strict();
+var redactionAttestationSchema = z4.object({
+  tokensAndSecretsRedacted: z4.literal(true),
+  authorizationHeadersRedacted: z4.literal(true),
+  refreshTokensRedacted: z4.literal(true),
+  customerPiiRedacted: z4.literal(true),
+  accountIdentifiersRedacted: z4.literal(true),
+  rawPayloadsMinimized: z4.literal(true),
+  statement: z4.string().min(1)
+}).strict();
+var approvalReferenceSchema = z4.object({
+  reference: z4.string().min(1),
+  approvedBy: z4.string().min(1),
+  approvedAt: capturedAtSchema.optional(),
+  approvedReadOnlyEndpoints: z4.array(z4.string().min(1)).min(1),
+  notes: z4.string().min(1).optional()
+}).strict();
+var operatorContextSchema = z4.object({
+  environment: z4.string().min(1),
+  commitSha: z4.string().min(1),
+  command: z4.string().min(1),
+  notes: z4.string().min(1).optional()
+}).strict();
+var endpointObservationSchema = z4.object({
+  service: z4.enum(API_SERVICES),
+  region: z4.enum(AMAZON_REGIONS),
+  expectedBaseUrl: httpsUrlSchema,
+  observedBaseUrl: httpsUrlSchema,
+  observedHost: z4.string().min(1),
+  notes: z4.string().min(1).optional()
+}).strict();
+var artifactReferenceSchema = z4.object({
+  path: z4.string().regex(REPO_RELATIVE_PATH_PATTERN, "Expected a repository-relative artifact path"),
+  kind: z4.enum(["example_fixture", "captured_artifact"]),
+  notes: z4.string().min(1)
+}).strict();
+var marketplaceCapabilityEvidenceCaptureBaseSchema = z4.object({
+  schemaVersion: z4.literal(MARKETPLACE_CAPABILITY_EVIDENCE_CAPTURE_SCHEMA_VERSION),
+  captureId: z4.string().min(1),
+  evidenceId: registryEvidenceIdSchema,
+  registryEvidenceIds: z4.array(registryEvidenceIdSchema).min(1),
+  marketplaceId: z4.string().min(1),
+  sourceType: z4.enum(MARKETPLACE_CAPABILITY_EVIDENCE_CAPTURE_SOURCE_TYPES),
+  status: z4.enum(MARKETPLACE_CAPABILITY_EVIDENCE_CAPTURE_STATUSES),
+  capturedAt: capturedAtSchema.optional(),
+  approvalReference: approvalReferenceSchema,
+  operator: operatorContextSchema,
+  endpoint: endpointObservationSchema,
+  observedFacts: z4.object({
+    marketplaceId: evidenceFactSchema,
+    countryCode: evidenceFactSchema,
+    currencyCode: evidenceFactSchema,
+    reportingTimeZone: evidenceFactSchema
+  }).strict(),
+  readOnlyCalls: z4.array(readOnlyCallSummarySchema).min(1),
+  noMutationAttestation: noMutationAttestationSchema,
+  redactionAttestation: redactionAttestationSchema,
+  artifact: artifactReferenceSchema,
+  notes: z4.string().min(1).optional()
+}).strict();
+function addIssue(ctx, path, message) {
+  ctx.addIssue({ code: z4.ZodIssueCode.custom, path: sanitizeIssuePath(path), message: safeIssueDisplay(message) });
+}
+function hostForUrl(value) {
+  try {
+    return new URL(value).host;
+  } catch {
+    return null;
+  }
+}
+function pathToString(path) {
+  const safePath = sanitizeRedactionPath(path);
+  if (safePath.length === 0) {
+    return "capture";
+  }
+  return safePath.reduce((formattedPath, segment) => {
+    if (typeof segment === "number") {
+      return `${formattedPath}[${segment}]`;
+    }
+    return formattedPath ? `${formattedPath}.${segment}` : segment;
+  }, "");
+}
+function stripTokenWrapper(value) {
+  return value.trim().replace(/^["'`]+|["'`,.;]+$/g, "");
+}
+function hasRedactionPlaceholder(value) {
+  return REDACTION_PLACEHOLDER_PATTERN.test(value);
+}
+function isExampleDomain(domain) {
+  return EXAMPLE_DOMAIN_PATTERN.test(domain.toLowerCase());
+}
+function isAllowedPlaceholderValue(value) {
+  const trimmed = stripTokenWrapper(value);
+  const lower = trimmed.toLowerCase();
+  return hasRedactionPlaceholder(trimmed) || /^0{12,}$/.test(trimmed) || /^x{6,}$/i.test(trimmed) || /^(?:example|synthetic|fixture)(?:[._:/ -][a-z0-9-]+)*$/i.test(trimmed) || lower === "example_only_no_approval" || lower === "example fixture only" || lower.startsWith("not run - offline example");
+}
+function isSensitiveFieldName(segment) {
+  const normalized = segment.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  if (normalized.includes("redacted") || normalized.includes("masked") || normalized.includes("placeholder")) {
+    return false;
+  }
+  return normalized === "authorization" || normalized === "proxyauthorization" || normalized === "apikey" || normalized === "xapikey" || normalized === "apitoken" || normalized === "accesstoken" || normalized === "refreshtoken" || normalized === "idtoken" || normalized === "clientsecret" || normalized === "secret" || normalized.endsWith("apikey") || normalized.endsWith("token") || normalized.endsWith("secret");
+}
+function lastStringPathSegment(path) {
+  for (let index = path.length - 1; index >= 0; index -= 1) {
+    const segment = path[index];
+    if (typeof segment === "string") {
+      return segment;
+    }
+  }
+  return null;
+}
+function isSensitiveFieldPath(path) {
+  const segment = lastStringPathSegment(path);
+  return segment ? isSensitiveFieldName(segment) : false;
+}
+function isCommitShaPath(path) {
+  return lastStringPathSegment(path) === "commitSha";
+}
+function shouldSkipGenericLongKeyScan(path) {
+  const segment = lastStringPathSegment(path);
+  return segment === "schemaVersion" || segment === "captureId" || segment === "evidenceId" || segment === "marketplaceId" || segment === "sourceType" || segment === "endpointPath" || segment === "redactedUrl" || segment === "expectedBaseUrl" || segment === "observedBaseUrl" || segment === "observedHost" || segment === "path" || path.includes("registryEvidenceIds") || path.includes("approvedReadOnlyEndpoints") || path.includes("returnedFieldNames");
+}
+function isAllowedEmailAddress(value) {
+  const domain = value.split("@").pop();
+  return Boolean(domain && isExampleDomain(domain)) || hasRedactionPlaceholder(value);
+}
+function isAllowedPhoneNumber(value) {
+  const digits = value.replace(/\D/g, "");
+  return /^0+$/.test(digits) || /^1?\d{3}55501\d{2}$/.test(digits) || hasRedactionPlaceholder(value);
+}
+function looksLikeLongKey(candidate) {
+  if (isAllowedPlaceholderValue(candidate)) {
+    return false;
+  }
+  const hasLetter = /[A-Za-z]/.test(candidate);
+  const hasDigit = /\d/.test(candidate);
+  const hasCredentialSeparator = /[_+=]/.test(candidate);
+  const hasMixedCase = /[a-z]/.test(candidate) && /[A-Z]/.test(candidate);
+  const isHexBlob = /^[a-f0-9]{32,}$/i.test(candidate);
+  return hasLetter && hasDigit && (hasCredentialSeparator || hasMixedCase || isHexBlob);
+}
+function addUniqueRedactionCategory(categories, category) {
+  if (!categories.includes(category)) {
+    categories.push(category);
+  }
+}
+function collectRedactionIssueCategories(value, path, options = {}) {
+  const categories = [];
+  const checkSensitiveFieldPath = options.checkSensitiveFieldPath ?? true;
+  const checkGenericLongKey = options.checkGenericLongKey ?? true;
+  if (checkSensitiveFieldPath && isSensitiveFieldPath(path) && !isAllowedPlaceholderValue(value)) {
+    addUniqueRedactionCategory(categories, "sensitive field value");
+  }
+  for (const match of value.matchAll(BEARER_TOKEN_PATTERN)) {
+    const token = match[1];
+    if (token && !isAllowedPlaceholderValue(token)) {
+      addUniqueRedactionCategory(categories, "bearer token");
+    }
+  }
+  for (const match of value.matchAll(AUTHORIZATION_HEADER_PATTERN)) {
+    const headerValue = match[1];
+    if (headerValue && !isAllowedPlaceholderValue(headerValue)) {
+      addUniqueRedactionCategory(categories, "authorization header value");
+    }
+  }
+  for (const match of value.matchAll(SENSITIVE_ASSIGNMENT_PATTERN)) {
+    const assignedValue = match[1];
+    if (assignedValue && !isAllowedPlaceholderValue(assignedValue)) {
+      addUniqueRedactionCategory(categories, "token or secret assignment");
+    }
+  }
+  for (const match of value.matchAll(AGENTCENTRAL_API_KEY_PATTERN)) {
+    if (!isAllowedPlaceholderValue(match[0])) {
+      addUniqueRedactionCategory(categories, "agentcentral API key");
+    }
+  }
+  for (const match of value.matchAll(AMAZON_TOKEN_PATTERN)) {
+    if (!isAllowedPlaceholderValue(match[0])) {
+      addUniqueRedactionCategory(categories, "Amazon token");
+    }
+  }
+  for (const match of value.matchAll(AWS_ACCESS_KEY_PATTERN)) {
+    if (!isAllowedPlaceholderValue(match[0])) {
+      addUniqueRedactionCategory(categories, "AWS access key");
+    }
+  }
+  for (const match of value.matchAll(EMAIL_ADDRESS_PATTERN)) {
+    if (!isAllowedEmailAddress(match[0])) {
+      addUniqueRedactionCategory(categories, "email address");
+    }
+  }
+  for (const match of value.matchAll(PHONE_NUMBER_PATTERN)) {
+    if (!isAllowedPhoneNumber(match[0])) {
+      addUniqueRedactionCategory(categories, "phone number");
+    }
+  }
+  for (const match of value.matchAll(INTERNATIONAL_PHONE_NUMBER_PATTERN)) {
+    if (!isAllowedPhoneNumber(match[0])) {
+      addUniqueRedactionCategory(categories, "phone number");
+    }
+  }
+  if (!checkGenericLongKey || isCommitShaPath(path) || shouldSkipGenericLongKeyScan(path)) {
+    return categories;
+  }
+  for (const match of value.matchAll(LONG_KEY_LIKE_PATTERN)) {
+    if (looksLikeLongKey(match[0])) {
+      addUniqueRedactionCategory(categories, "long key-like string");
+    }
+  }
+  return categories;
+}
+function shouldRedactCapturedCredentialValue(value) {
+  const normalized = stripTokenWrapper(value).toLowerCase();
+  return normalized !== "token" && normalized !== "secret" && normalized !== "value" && normalized !== "key" && normalized !== "credential" && normalized !== "credentials" && !isAllowedPlaceholderValue(value);
+}
+function replaceSensitiveSubstrings(value, placeholder) {
+  let sanitized = value;
+  sanitized = sanitized.replace(BEARER_TOKEN_PATTERN, (match, token) => {
+    if (!token || !shouldRedactCapturedCredentialValue(token)) {
+      return match;
+    }
+    return match.replace(token, placeholder);
+  });
+  sanitized = sanitized.replace(AUTHORIZATION_HEADER_PATTERN, (match, headerValue) => {
+    if (!headerValue || !shouldRedactCapturedCredentialValue(headerValue)) {
+      return match;
+    }
+    return match.replace(headerValue, placeholder);
+  });
+  sanitized = sanitized.replace(SENSITIVE_ASSIGNMENT_PATTERN, (match, assignedValue) => {
+    if (!assignedValue || !shouldRedactCapturedCredentialValue(assignedValue)) {
+      return match;
+    }
+    return match.replace(assignedValue, placeholder);
+  });
+  sanitized = sanitized.replace(AGENTCENTRAL_API_KEY_PATTERN, (match) => {
+    return isAllowedPlaceholderValue(match) ? match : placeholder;
+  });
+  sanitized = sanitized.replace(AMAZON_TOKEN_PATTERN, (match) => {
+    return isAllowedPlaceholderValue(match) ? match : placeholder;
+  });
+  sanitized = sanitized.replace(AWS_ACCESS_KEY_PATTERN, (match) => {
+    return isAllowedPlaceholderValue(match) ? match : placeholder;
+  });
+  sanitized = sanitized.replace(EMAIL_ADDRESS_PATTERN, (match) => {
+    return isAllowedEmailAddress(match) ? match : placeholder;
+  });
+  sanitized = sanitized.replace(PHONE_NUMBER_PATTERN, (match) => {
+    return isAllowedPhoneNumber(match) ? match : placeholder;
+  });
+  sanitized = sanitized.replace(INTERNATIONAL_PHONE_NUMBER_PATTERN, (match) => {
+    return isAllowedPhoneNumber(match) ? match : placeholder;
+  });
+  sanitized = sanitized.replace(LONG_KEY_LIKE_PATTERN, (match) => {
+    return looksLikeLongKey(match) ? placeholder : match;
+  });
+  return sanitized;
+}
+function safeIssueDisplay(value) {
+  return replaceSensitiveSubstrings(value, REDACTED_VALUE_SEGMENT);
+}
+function safeIssueKeyDisplay(value) {
+  return replaceSensitiveSubstrings(value, REDACTED_PATH_SEGMENT);
+}
+function sanitizeIssuePath(path) {
+  return path.map((segment) => {
+    if (typeof segment === "string") {
+      return safeIssueKeyDisplay(segment);
+    }
+    return segment;
+  });
+}
+function pathSegmentContainsSensitiveEvidence(segment) {
+  return collectRedactionIssueCategories(segment, [segment], {
+    checkSensitiveFieldPath: false,
+    checkGenericLongKey: true
+  }).length > 0;
+}
+function sanitizeRedactionPath(path) {
+  return path.map((segment) => {
+    if (typeof segment === "string" && pathSegmentContainsSensitiveEvidence(segment)) {
+      return REDACTED_PATH_SEGMENT;
+    }
+    return segment;
+  });
+}
+function addRedactionIssue(ctx, path, category) {
+  const safePath = sanitizeRedactionPath(path);
+  addIssue(
+    ctx,
+    safePath,
+    `Potential unredacted ${category} in evidence capture at ${pathToString(safePath)}; replace the value or dynamic key with [REDACTED], <redacted>, ***, REDACTED, an example.invalid address, or another explicit synthetic placeholder.`
+  );
+}
+function validateEvidenceStringRedaction(value, path, ctx) {
+  collectRedactionIssueCategories(value, path).forEach((category) => {
+    addRedactionIssue(ctx, path, category);
+  });
+}
+function validateEvidenceObjectKeyRedaction(key, path, ctx) {
+  const keyPath = [...path, key];
+  collectRedactionIssueCategories(key, keyPath, {
+    checkSensitiveFieldPath: false,
+    checkGenericLongKey: true
+  }).forEach((category) => {
+    addRedactionIssue(ctx, keyPath, `object key ${category}`);
+  });
+}
+function validateEvidenceRedactionGuardrails(value, ctx, path = []) {
+  if (typeof value === "string") {
+    validateEvidenceStringRedaction(value, path, ctx);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => validateEvidenceRedactionGuardrails(item, ctx, [...path, index]));
+    return;
+  }
+  if (value && typeof value === "object") {
+    Object.entries(value).forEach(([key, nestedValue]) => {
+      validateEvidenceObjectKeyRedaction(key, path, ctx);
+      validateEvidenceRedactionGuardrails(nestedValue, ctx, [...path, key]);
+    });
+  }
+}
+function validateRegistryLinks(capture, ctx) {
+  const uniqueEvidenceIds = new Set(capture.registryEvidenceIds);
+  if (uniqueEvidenceIds.size !== capture.registryEvidenceIds.length) {
+    addIssue(ctx, ["registryEvidenceIds"], "Expected registry evidence IDs to be unique");
+  }
+  if (!uniqueEvidenceIds.has(capture.evidenceId)) {
+    addIssue(ctx, ["evidenceId"], "Primary evidence ID must also appear in registryEvidenceIds");
+  }
+  const primaryRecord = getMarketplaceCapabilityEvidenceRecord(capture.evidenceId);
+  if (!primaryRecord) {
+    addIssue(ctx, ["evidenceId"], `Unknown marketplace capability evidence ID: ${safeIssueDisplay(capture.evidenceId)}`);
+  } else {
+    if (primaryRecord.sourceType !== "live_smoke") {
+      addIssue(ctx, ["evidenceId"], "Capture artifacts are only valid for live_smoke registry records");
     }
-    if (res.status === 401) {
-      throw new CliError(
-        3 /* AuthError */,
-        "Authentication failed (HTTP 401): the API key was rejected by the hosted server.",
-        method
-      );
+    if (primaryRecord.operation !== "read") {
+      addIssue(ctx, ["evidenceId"], "Capture artifacts are only valid for read-only registry records");
     }
-    if (res.status === 429 || res.status >= 500) {
-      const retryAfterMs = retry.honorRetryAfter ? parseRetryAfterMs(res.headers.get("retry-after"), Date.now()) : void 0;
-      throw new RetryableError(`HTTP ${res.status}`, {
-        status: res.status,
-        retryAfterMs
-      });
+  }
+  const nonMarketplaceScopes = /* @__PURE__ */ new Set([
+    GLOBAL_MARKETPLACE_CAPABILITY_EVIDENCE_SCOPE,
+    COMMON_MARKETPLACE_CAPABILITY_EVIDENCE_SCOPE
+  ]);
+  capture.registryEvidenceIds.forEach((evidenceId, index) => {
+    const record = getMarketplaceCapabilityEvidenceRecord(evidenceId);
+    if (!record) {
+      addIssue(ctx, ["registryEvidenceIds", index], `Unknown marketplace capability evidence ID: ${safeIssueDisplay(evidenceId)}`);
+      return;
     }
-    const text = await res.text();
-    if (!res.ok) {
-      throw new CliError(
-        6 /* TransportFailure */,
-        `HTTP ${res.status}: ${text.slice(0, 200)}`,
-        method
+    if (!nonMarketplaceScopes.has(record.marketplaceId) && record.marketplaceId !== capture.marketplaceId) {
+      addIssue(
+        ctx,
+        ["registryEvidenceIds", index],
+        `Evidence ID ${safeIssueDisplay(evidenceId)} is scoped to ${safeIssueDisplay(record.marketplaceId)}, not ${safeIssueDisplay(capture.marketplaceId)}`
       );
     }
-    return parseSseJsonRpc(text);
-  }
-  async function rpc(method, params, rpcOpts) {
-    const timeoutMs = rpcOpts?.timeoutMs ?? defaultTimeoutMs;
-    const id = rpcOpts?.id ?? nextId();
-    const maxAttempts = Math.max(1, retry.maxAttempts);
-    let lastReason = "transport failure";
-    for (let n = 1; n <= maxAttempts; n += 1) {
-      try {
-        return await attempt(method, params ?? {}, id, timeoutMs);
-      } catch (error) {
-        if (error instanceof CliError) {
-          throw error;
-        }
-        if (!(error instanceof RetryableError)) {
-          throw error;
-        }
-        lastReason = error.message;
-        if (n >= maxAttempts) break;
-        const backoffMs = retry.baseBackoffMs * 2 ** (n - 1);
-        const delayMs = error.retryAfterMs ?? backoffMs;
-        opts.onRetry?.({ attempt: n, delayMs, reason: lastReason });
-        await sleep(delayMs);
-      }
+  });
+}
+function validateStatusFields(capture, ctx) {
+  if (capture.status === "example") {
+    if (capture.capturedAt) {
+      addIssue(ctx, ["capturedAt"], "Example captures must omit capturedAt so they are not mistaken for recorded evidence");
     }
-    throw new CliError(
-      6 /* TransportFailure */,
-      `Transport failure after ${maxAttempts} attempt(s): ${lastReason}`,
-      method
-    );
-  }
-  async function listTools(listOpts) {
-    const response = await rpc("tools/list", {}, { timeoutMs: listOpts?.timeoutMs });
-    if (response.error) {
-      throw new CliError(7 /* ToolExecutionFailed */, response.error.message, "tools/list");
+    if (capture.artifact.kind !== "example_fixture") {
+      addIssue(ctx, ["artifact", "kind"], "Example captures must use artifact.kind=example_fixture");
     }
-    const result = response.result ?? {};
-    return result.tools ?? [];
+    return;
   }
-  async function callTool(name, args, callOpts) {
-    const response = await rpc(
-      "tools/call",
-      { name, arguments: args },
-      { timeoutMs: callOpts?.timeoutMs }
-    );
-    if (response.error) {
-      throw new CliError(7 /* ToolExecutionFailed */, response.error.message, name);
+  if (!capture.capturedAt) {
+    addIssue(ctx, ["capturedAt"], "Captured or failed real smoke captures must include capturedAt");
+  }
+  if (capture.artifact.kind !== "captured_artifact") {
+    addIssue(ctx, ["artifact", "kind"], "Real smoke captures must use artifact.kind=captured_artifact");
+  }
+}
+function validateMarketplaceFacts(capture, ctx) {
+  const marketplace = getMarketplaceDefinition(capture.marketplaceId);
+  if (!marketplace) {
+    addIssue(ctx, ["marketplaceId"], `Unknown marketplace ID: ${safeIssueDisplay(capture.marketplaceId)}`);
+    return;
+  }
+  const expectedFactValues = {
+    marketplaceId: capture.marketplaceId,
+    countryCode: marketplace.countryCode,
+    currencyCode: marketplace.currencyCode,
+    reportingTimeZone: marketplace.defaultReportingTimeZone
+  };
+  for (const [factName, expectedValue] of Object.entries(expectedFactValues)) {
+    const fact = capture.observedFacts[factName];
+    const factPath = ["observedFacts", factName];
+    if (fact.expected !== expectedValue) {
+      addIssue(ctx, [...factPath, "expected"], `Expected ${factName} to match marketplace registry value ${expectedValue}`);
+    }
+    if (fact.observed === null && fact.matchesExpected) {
+      addIssue(ctx, [...factPath, "matchesExpected"], `Cannot mark ${factName} as matching when observed is null`);
+    }
+    if (fact.observed !== null && fact.matchesExpected !== (fact.observed === fact.expected)) {
+      addIssue(ctx, [...factPath, "matchesExpected"], `matchesExpected must reflect whether observed equals expected for ${factName}`);
+    }
+    if (capture.status !== "failed" && (!fact.observed || !fact.matchesExpected)) {
+      addIssue(ctx, factPath, `Non-failed captures must include matching observed ${factName} evidence`);
     }
-    return response.result ?? {};
   }
-  return { rpc, listTools, callTool };
+  const expectedEndpoint = capture.sourceType === "ads_api_readonly_smoke" ? {
+    service: "ads",
+    region: marketplace.adsRegion,
+    baseUrl: marketplace.adsApiBaseUrl
+  } : {
+    service: "sp_api",
+    region: marketplace.spApiRegion,
+    baseUrl: marketplace.spApiBaseUrl
+  };
+  if (capture.endpoint.service !== expectedEndpoint.service) {
+    addIssue(ctx, ["endpoint", "service"], `Expected endpoint.service=${expectedEndpoint.service} for ${capture.sourceType}`);
+  }
+  if (capture.endpoint.region !== expectedEndpoint.region) {
+    addIssue(ctx, ["endpoint", "region"], `Expected endpoint.region=${safeIssueDisplay(expectedEndpoint.region)} for marketplace ${safeIssueDisplay(capture.marketplaceId)}`);
+  }
+  if (capture.endpoint.expectedBaseUrl !== expectedEndpoint.baseUrl) {
+    addIssue(ctx, ["endpoint", "expectedBaseUrl"], `Expected endpoint base URL to match registry value ${expectedEndpoint.baseUrl}`);
+  }
+  const observedHostFromUrl = hostForUrl(capture.endpoint.observedBaseUrl);
+  if (observedHostFromUrl && observedHostFromUrl !== capture.endpoint.observedHost) {
+    addIssue(ctx, ["endpoint", "observedHost"], "observedHost must match observedBaseUrl host");
+  }
+  const expectedHost = hostForUrl(expectedEndpoint.baseUrl);
+  if (capture.status !== "failed" && expectedHost && capture.endpoint.observedHost !== expectedHost) {
+    addIssue(ctx, ["endpoint", "observedHost"], `Non-failed captures must observe expected host ${expectedHost}`);
+  }
 }
-
-// src/commands/tools.ts
-import { readFile, writeFile } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { TOOL_DOMAINS } from "@agent-central/shared";
+var marketplaceCapabilityEvidenceCaptureSchema = marketplaceCapabilityEvidenceCaptureBaseSchema.superRefine((capture, ctx) => {
+  validateRegistryLinks(capture, ctx);
+  validateStatusFields(capture, ctx);
+  validateMarketplaceFacts(capture, ctx);
+  validateEvidenceRedactionGuardrails(capture, ctx);
+});
 
 // src/format.ts
 function isTabular(value) {
@@ -490,123 +3287,6 @@ function formatOutput(value, format) {
   }
 }
 
-// src/exit-codes.ts
-var RPC_INVALID_PARAMS = -32602;
-var DETAIL_MAX_LENGTH = 180;
-var PERMISSION_PATTERN = /no_amazon|not connected|expired|suspended|revoked|past_due|trial expired|permission|not authorized|scope/i;
-var VALIDATION_PATTERN = /invalid|validation|must be|required/i;
-function writeEnvelopeFrom(result) {
-  const structured = result.structuredContent;
-  if (!structured) {
-    return void 0;
-  }
-  const hasWriteShape = "mode" in structured || "status" in structured || "requested_count" in structured;
-  if (!hasWriteShape) {
-    return void 0;
-  }
-  return structured;
-}
-function toolClassification(def) {
-  const hint = def.annotations;
-  const annotationWrite = hint?.destructiveHint === true || hint?.readOnlyHint === false;
-  const properties = def.inputSchema.properties;
-  const props = properties && typeof properties === "object" ? properties : {};
-  const schemaWrite = "confirm" in props && "idempotency_key" in props;
-  const isWrite = annotationWrite || schemaWrite;
-  return {
-    isWrite,
-    supportsPreview: isWrite
-  };
-}
-function classifyToolText(text) {
-  if (PERMISSION_PATTERN.test(text)) {
-    return 4 /* PermissionDenied */;
-  }
-  if (VALIDATION_PATTERN.test(text)) {
-    return 5 /* ValidationFailed */;
-  }
-  return void 0;
-}
-function joinContentText(result) {
-  return result.content.map((block) => typeof block.text === "string" ? block.text : "").filter((text) => text.length > 0).join(" ").trim();
-}
-function truncateDetail(text) {
-  if (text.length <= DETAIL_MAX_LENGTH) {
-    return text;
-  }
-  return `${text.slice(0, DETAIL_MAX_LENGTH)}\u2026`;
-}
-function classifyWriteStatus(status) {
-  switch (status) {
-    case "validation_error":
-      return 5 /* ValidationFailed */;
-    case "partial":
-      return 9 /* PartialWrite */;
-    case "blocked":
-    case "failed":
-      return 7 /* ToolExecutionFailed */;
-    case "duplicate_blocked":
-    case "accepted":
-    case "preview":
-    default:
-      return 0 /* Success */;
-  }
-}
-function summarizeWriteEnvelope(env) {
-  const parts = [];
-  if (typeof env.requested_count === "number") {
-    parts.push(`requested=${env.requested_count}`);
-  }
-  if (typeof env.accepted_count === "number") {
-    parts.push(`accepted=${env.accepted_count}`);
-  }
-  if (typeof env.failed_count === "number") {
-    parts.push(`failed=${env.failed_count}`);
-  }
-  if (typeof env.previewed_count === "number") {
-    parts.push(`previewed=${env.previewed_count}`);
-  }
-  const status = env.status ?? "unknown";
-  return parts.length > 0 ? `${status} (${parts.join(", ")})` : status;
-}
-function classifyResponse(response) {
-  if (response.error) {
-    const message = response.error.message;
-    const code = response.error.code === RPC_INVALID_PARAMS ? 5 /* ValidationFailed */ : classifyToolText(message) ?? 7 /* ToolExecutionFailed */;
-    return {
-      code,
-      status: "rpc_error",
-      detail: message
-    };
-  }
-  const result = response.result;
-  const env = writeEnvelopeFrom(result);
-  if (env?.status) {
-    return {
-      code: classifyWriteStatus(env.status),
-      status: env.status,
-      detail: summarizeWriteEnvelope(env),
-      result
-    };
-  }
-  if (result.isError) {
-    const text = joinContentText(result);
-    const code = classifyToolText(text) ?? 7 /* ToolExecutionFailed */;
-    return {
-      code,
-      status: "tool_error",
-      detail: truncateDetail(text),
-      result
-    };
-  }
-  return {
-    code: 0 /* Success */,
-    status: "ok",
-    detail: truncateDetail(joinContentText(result)),
-    result
-  };
-}
-
 // src/commands/tools.ts
 function parseJsonArgs(text, origin) {
   try {
@@ -766,6 +3446,14 @@ function selectOutputValue(result) {
     return text;
   }
 }
+function warnIfLimitTruncated(ctx, value) {
+  const limit = ctx.flags.limit;
+  if (limit != null && Array.isArray(value) && value.length === limit) {
+    ctx.err(
+      `warning: result returned exactly --limit (${limit}) rows; output may be truncated. Raise --limit or narrow the query.`
+    );
+  }
+}
 function echoWriteSummary(ctx, result) {
   const env = writeEnvelopeFrom(result);
   if (!env) {
@@ -803,6 +3491,7 @@ async function toolsCall(ctx, name, inputSpec) {
   }
   echoWriteSummary(ctx, result);
   const value = selectOutputValue(result);
+  warnIfLimitTruncated(ctx, value);
   const rendered = formatOutput(value, ctx.flags.format);
   if (ctx.flags.output) {
     await writeFile(ctx.flags.output, rendered, { encoding: "utf8", mode: 384 });
@@ -821,9 +3510,8 @@ async function readStdinOnce() {
 }
 
 // src/commands/mcp.ts
-import { TOOL_DOMAINS as TOOL_DOMAINS2 } from "@agent-central/shared";
-var DOMAIN_BY_TOOL = new Map(
-  TOOL_DOMAINS2.flatMap(
+var DOMAIN_BY_TOOL2 = new Map(
+  TOOL_DOMAINS.flatMap(
     (domain) => domain.tools.map((tool) => [tool.name, domain.serverDomain])
   )
 );
@@ -834,7 +3522,7 @@ function filterToolsList(tools, opts) {
       return false;
     }
     if (domainSet) {
-      const domain = DOMAIN_BY_TOOL.get(def.name);
+      const domain = DOMAIN_BY_TOOL2.get(def.name);
       if (domain !== void 0 && !domainSet.has(domain)) {
         return false;
       }
@@ -861,7 +3549,7 @@ async function handleMessage(line, client, opts) {
   const method = typeof message.method === "string" ? message.method : "";
   if (message.id === void 0) {
     try {
-      await client.rpc(method, message.params);
+      await client.rpc(method, message.params, { notification: true });
     } catch {
     }
     return null;
@@ -934,9 +3622,9 @@ function pump(ctx, client, opts, input = process.stdin) {
   return new Promise((resolve, reject) => {
     input.setEncoding("utf8");
     let buffer = "";
-    let chain = Promise.resolve();
+    const inflight = /* @__PURE__ */ new Set();
     const dispatch = (line) => {
-      chain = chain.then(async () => {
+      const task = (async () => {
         try {
           const out = await handleMessage(line, client, opts);
           if (out !== null) {
@@ -945,6 +3633,10 @@ function pump(ctx, client, opts, input = process.stdin) {
         } catch (error) {
           ctx.err(`bridge error: ${error instanceof Error ? error.message : String(error)}`);
         }
+      })();
+      inflight.add(task);
+      void task.finally(() => {
+        inflight.delete(task);
       });
     };
     input.on("data", (data) => {
@@ -966,10 +3658,10 @@ function pump(ctx, client, opts, input = process.stdin) {
       if (tail.trim() !== "") {
         dispatch(tail);
       }
-      chain.then(() => {
+      Promise.allSettled([...inflight]).then(() => {
         ctx.err("bridge stopped (stdin closed)");
         resolve(0 /* Success */);
-      }).catch(reject);
+      }, reject);
     });
   });
 }
@@ -1375,17 +4067,37 @@ async function profilesUse(ctx, name) {
 }
 
 // src/keychain.ts
-import { Entry } from "@napi-rs/keyring";
+import { createRequire } from "module";
 var SERVICE = "agentcentral-cli";
 var DEFAULT_ACCOUNT = "default";
 var DISABLE_ENV = "AGENT_CENTRAL_DISABLE_KEYCHAIN";
+var entryClassCache = void 0;
+var loaderOverride = void 0;
 function disabled() {
   return process.env[DISABLE_ENV] === "1";
 }
+var requireNative = createRequire(import.meta.url);
+function loadEntryClass() {
+  if (entryClassCache !== void 0) {
+    return entryClassCache;
+  }
+  try {
+    const loaded = loaderOverride ? loaderOverride() : requireNative("@napi-rs/keyring").Entry;
+    entryClassCache = loaded;
+    return loaded;
+  } catch {
+    entryClassCache = null;
+    return null;
+  }
+}
 function keychainAvailable() {
   if (disabled()) {
     return false;
   }
+  const Entry = loadEntryClass();
+  if (!Entry) {
+    return false;
+  }
   try {
     const entry = new Entry(SERVICE, DEFAULT_ACCOUNT);
     try {
@@ -1401,6 +4113,10 @@ function keychainGet(account) {
   if (disabled()) {
     return null;
   }
+  const Entry = loadEntryClass();
+  if (!Entry) {
+    return null;
+  }
   try {
     const entry = new Entry(SERVICE, account ?? DEFAULT_ACCOUNT);
     const secret = entry.getPassword();
@@ -1414,6 +4130,10 @@ function keychainSet(account, secret) {
   if (disabled()) {
     return false;
   }
+  const Entry = loadEntryClass();
+  if (!Entry) {
+    return false;
+  }
   try {
     const entry = new Entry(SERVICE, account ?? DEFAULT_ACCOUNT);
     entry.setPassword(secret);
@@ -1426,6 +4146,10 @@ function keychainDelete(account) {
   if (disabled()) {
     return false;
   }
+  const Entry = loadEntryClass();
+  if (!Entry) {
+    return false;
+  }
   try {
     const entry = new Entry(SERVICE, account ?? DEFAULT_ACCOUNT);
     return entry.deletePassword();
@@ -1514,7 +4238,6 @@ function extraFlags(ctx) {
   const flags = ctx.flags;
   return {
     since: flags.since,
-    groupBy: flags.groupBy,
     asin: flags.asin,
     fulfillmentChannel: flags.fulfillmentChannel
   };
@@ -1549,6 +4272,14 @@ function selectOutputValue2(result) {
     return text;
   }
 }
+function warnIfLimitTruncated2(ctx, value) {
+  const limit = ctx.flags.limit;
+  if (limit != null && Array.isArray(value) && value.length === limit) {
+    ctx.err(
+      `warning: result returned exactly --limit (${limit}) rows; output may be truncated. Raise --limit or narrow the query.`
+    );
+  }
+}
 async function emit(ctx, name, args) {
   const client = await ctx.getClient();
   const response = await client.rpc(
@@ -1565,6 +4296,7 @@ async function emit(ctx, name, args) {
     return classified.code;
   }
   const value = selectOutputValue2(result);
+  warnIfLimitTruncated2(ctx, value);
   const rendered = formatOutput(value, ctx.flags.format);
   if (ctx.flags.output) {
     await writeFile2(ctx.flags.output, rendered, { encoding: "utf8", mode: 384 });
@@ -1844,9 +4576,9 @@ async function run(argv) {
   withGlobalOptions(cli.command("inventory health", "summarize inventory health")).action(
     (options) => dispatch((ctx) => inventoryHealth(ctx), options)
   );
-  withGlobalOptions(cli.command("ads performance", "summarize campaign performance")).option("--since <dur>", "lookback window: a relative duration like 30d or a YYYY-MM-DD date").option("--group-by <field>", "advisory grain hint (documented; not wired server-side)").action(
+  withGlobalOptions(cli.command("ads performance", "summarize campaign performance")).option("--since <dur>", "lookback window: a relative duration like 30d or a YYYY-MM-DD date").action(
     (options) => dispatch((ctx) => adsPerformance(ctx), options, {
-      extra: { since: asString(options.since), groupBy: asString(options.groupBy) }
+      extra: { since: asString(options.since) }
     })
   );
   withGlobalOptions(cli.command("catalog quality", "summarize listing quality")).option("--asin <asin>", "scope to a single ASIN").action(