hive-intelligence 1.3.0 → 1.4.0

package/build/{chunk-W2QL7LYI.js → chunk-UFTNBCSA.js}

@@ -17608,11 +17608,11 @@ var require_client = __commonJS({
     };
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.TerminatedCloseEvent = void 0;
-    exports.createClient = createClient2;
+    exports.createClient = createClient3;
     var common_1 = require_common();
     var utils_1 = require_utils();
     __exportStar(require_common(), exports);
-    function createClient2(options) {
+    function createClient3(options) {
       const {
         url,
         connectionParams,
@@ -20827,7 +20827,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash7 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash8 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -21495,7 +21495,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash8("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -21864,7 +21864,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash7 } = __require("crypto");
+    var { createHash: createHash8 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -22171,7 +22171,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash8("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -25358,6 +25358,11 @@ function getPort() {
 function getRateLimitMax() {
   return rateLimitMaxSchema.parse(process.env.RATE_LIMIT_MAX ?? 30);
 }
+function getCredentialedRateLimitMax() {
+  return rateLimitMaxSchema.parse(
+    process.env.CREDENTIALED_RATE_LIMIT_MAX ?? 1500
+  );
+}
 function getCorsAllowedOrigins() {
   return getCsvEnv("CORS_ALLOWED_ORIGINS");
 }
@@ -32582,7 +32587,7 @@ Don't use when:
 
 Error Handling:
   - Returns 404 if NFT collection ID not found
-  - Requires Analyst plan or higher
+  - Requires CoinGecko's Analyst plan or higher (a provider tier, not a Hive plan)
   - Rate limited to 10-50 calls/minute depending on API plan`,
   inputSchema: {
     type: "object",
@@ -32700,7 +32705,7 @@ Don't use when:
   - You need historical NFT data (use coingecko_get_nft_market_chart)
 
 Error Handling:
-  - Requires Analyst plan or higher
+  - Requires CoinGecko's Analyst plan or higher (a provider tier, not a Hive plan)
   - Rate limited to 10-50 calls/minute depending on API plan`,
   inputSchema: {
     type: "object",
@@ -33112,7 +33117,7 @@ Don't use when:
 
 Error Handling:
   - Returns 404 if network or token address not found
-  - Requires Analyst plan or higher
+  - Requires CoinGecko's Analyst plan or higher (a provider tier, not a Hive plan)
   - Not all networks support trader tracking
   - Rate limited based on API plan`,
   inputSchema: {
@@ -33187,7 +33192,7 @@ Don't use when:
 
 Error Handling:
   - Returns 404 if contract not found on the specified platform
-  - Requires Analyst plan or higher
+  - Requires CoinGecko's Analyst plan or higher (a provider tier, not a Hive plan)
   - Rate limited based on API plan`,
   inputSchema: {
     type: "object",
@@ -33824,7 +33829,6 @@ var get_insights_default = { metadata: metadata88, tool: tool88, handler: handle
 // src/db/supabase.ts
 import { createClient } from "@supabase/supabase-js";
 var _supabaseAdmin = null;
-var _supabaseAuth = null;
 function isSupabaseConfigured() {
   return hasEnvVars("SUPABASE_URL", "SUPABASE_SERVICE_ROLE_KEY");
 }
@@ -33843,21 +33847,6 @@ function getSupabaseAdmin() {
   }
   return _supabaseAdmin;
 }
-function getSupabaseAuthClient() {
-  if (!_supabaseAuth) {
-    if (!hasEnvVars("SUPABASE_URL", "SUPABASE_ANON_KEY")) {
-      throw new Error(
-        "Supabase auth client not configured. Set SUPABASE_URL and SUPABASE_ANON_KEY."
-      );
-    }
-    _supabaseAuth = createClient(
-      getRequiredEnvVar("SUPABASE_URL"),
-      getRequiredEnvVar("SUPABASE_ANON_KEY"),
-      { auth: { persistSession: false, autoRefreshToken: false } }
-    );
-  }
-  return _supabaseAuth;
-}
 
 // src/utils/secureLogger.ts
 var SENSITIVE_PATTERNS = [
@@ -33894,7 +33883,7 @@ var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
   "GOPLUS_API_KEY"
 ]);
 function isSensitiveEnvironmentKey(key) {
-  return /(?:api[_-]?(?:key|id)|key|secret|password|token|auth|credential|private|bearer|redis.*url)/i.test(
+  return /(?:api[_-]?(?:key|id)|key|secret|password|token|auth|credential|private|bearer|redis.*url|sharpe_archive_supabase)/i.test(
     key
   );
 }
@@ -34497,6 +34486,23 @@ async function listSubjectAuditEvents(args) {
   }
   return { ok: true, data: data ?? [] };
 }
+function buildStatefulWriteAuditEvent(input) {
+  if (!input.isStatefulWrite) return null;
+  const userId = input.subjectContext?.userId ?? input.userId;
+  if (!userId) return null;
+  return {
+    userId,
+    subjectId: input.subjectContext?.subjectId,
+    keyId: input.keyId,
+    transport: input.transport,
+    toolName: input.toolName,
+    requestId: input.requestId,
+    metadata: {
+      ...input.authMethod ? { auth_method: input.authMethod } : {},
+      ...input.authMethod === "oauth" ? { oauth_client_id: input.oauthClientId ?? null } : {}
+    }
+  };
+}
 function recordSubjectAuditEvent(args) {
   if (!isSupabaseConfigured()) return;
   getSupabaseAdmin().from("state_subject_audit_events").insert({
@@ -46384,8 +46390,8 @@ Don't use when:
     }
     if (tokens) filterParams.tokens = tokens;
     const MAX_SAFE_LIMIT = RESPONSE_LIMITS.MAX_LIMITS.tokens;
-    const DEFAULT_LIMIT2 = RESPONSE_LIMITS.DEFAULT_LIMITS.tokens;
-    const requestedLimit = limit || DEFAULT_LIMIT2;
+    const DEFAULT_LIMIT3 = RESPONSE_LIMITS.DEFAULT_LIMITS.tokens;
+    const requestedLimit = limit || DEFAULT_LIMIT3;
     const finalLimit = Math.min(requestedLimit, MAX_SAFE_LIMIT);
     filterParams.limit = finalLimit;
     filterParams.offset = offset || 0;
@@ -51866,8 +51872,8 @@ Error Handling:
       },
       async execute(args) {
         const MAX_SAFE_LIMIT = 50;
-        const DEFAULT_LIMIT2 = 30;
-        const limit = Math.min(args?.limit || DEFAULT_LIMIT2, MAX_SAFE_LIMIT);
+        const DEFAULT_LIMIT3 = 30;
+        const limit = Math.min(args?.limit || DEFAULT_LIMIT3, MAX_SAFE_LIMIT);
         const offset = args?.offset || 0;
         try {
           const data = await apiClient.getProtocols();
@@ -52975,8 +52981,8 @@ Error Handling:
       },
       async execute(args) {
         const MAX_SAFE_LIMIT = 100;
-        const DEFAULT_LIMIT2 = 50;
-        const limit = Math.min(args?.limit || DEFAULT_LIMIT2, MAX_SAFE_LIMIT);
+        const DEFAULT_LIMIT3 = 50;
+        const limit = Math.min(args?.limit || DEFAULT_LIMIT3, MAX_SAFE_LIMIT);
         const offset = args?.offset || 0;
         const minTvl = args?.minTvl || 0;
         try {
@@ -55092,8 +55098,8 @@ Error Handling:
       },
       async execute(args) {
         const MAX_SAFE_LIMIT = 100;
-        const DEFAULT_LIMIT2 = 50;
-        const limit = Math.min(args.limit || DEFAULT_LIMIT2, MAX_SAFE_LIMIT);
+        const DEFAULT_LIMIT3 = 50;
+        const limit = Math.min(args.limit || DEFAULT_LIMIT3, MAX_SAFE_LIMIT);
         const offset = args.offset || 0;
         const minFees = args.minFees || 0;
         try {
@@ -80540,6 +80546,594 @@ Don't use when:
   ];
 }
 
+// src/tools/archive/client.ts
+import { createClient as createClient2 } from "@supabase/supabase-js";
+var ARCHIVE_URL_ENV = "SHARPE_ARCHIVE_SUPABASE_URL";
+var ARCHIVE_KEY_ENV = "SHARPE_ARCHIVE_SUPABASE_SERVICE_ROLE_KEY";
+var ARCHIVE_MISSING_CREDENTIALS_MESSAGE = `Hive Archive credentials not configured \u2014 set ${ARCHIVE_URL_ENV} and ${ARCHIVE_KEY_ENV} to enable archive_ history tools. Until then use the live derivatives tools (ccxt_fetch_funding_rates_multi, hyperliquid_get_funding_history) for current data.`;
+var _archiveClient = null;
+function isArchiveConfigured() {
+  return hasEnvVars(ARCHIVE_URL_ENV, ARCHIVE_KEY_ENV);
+}
+function getArchiveClient() {
+  if (!isArchiveConfigured()) return null;
+  if (!_archiveClient) {
+    _archiveClient = createClient2(
+      getEnvVar(ARCHIVE_URL_ENV),
+      getEnvVar(ARCHIVE_KEY_ENV),
+      { auth: { persistSession: false, autoRefreshToken: false } }
+    );
+  }
+  return _archiveClient;
+}
+
+// src/tools/archive/api.ts
+var DEFAULT_LIMIT2 = 100;
+var MAX_LIMIT2 = 500;
+var ARCHIVE_SINCE_NOTE = "archive since 2023-11";
+var QUERY_TIMEOUT_MS = 1e4;
+var VENUE_SCAN_MAX_STEPS = 64;
+var COVERAGE_CACHE_TTL_MS = 10 * 60 * 1e3;
+var COVERAGE_CACHE_MAX_ENTRIES = 16;
+var HOURS_PER_YEAR2 = 8760;
+function annualizeRate(rate, intervalHours) {
+  if (!Number.isFinite(rate)) return null;
+  if (!Number.isFinite(intervalHours) || intervalHours <= 0) return null;
+  return rate * (HOURS_PER_YEAR2 / intervalHours);
+}
+function clampLimit3(value) {
+  const parsed = typeof value === "number" ? Math.floor(value) : NaN;
+  if (!Number.isFinite(parsed)) return DEFAULT_LIMIT2;
+  return Math.min(Math.max(parsed, 1), MAX_LIMIT2);
+}
+function escapeLikeLiteral(value) {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+var ArchiveInputError = class extends Error {
+};
+function normalizeBaseCoin(value) {
+  const coin = typeof value === "string" ? value.trim().toUpperCase() : "";
+  if (!coin) {
+    throw new ArchiveInputError(
+      'base_coin is required \u2014 pass the base asset ticker, e.g. "BTC" or "ETH". Call archive_get_coverage to see which venues and datasets the archive holds.'
+    );
+  }
+  return coin;
+}
+function normalizeExchange(value) {
+  if (typeof value !== "string") return null;
+  const exchange = value.trim();
+  return exchange === "" ? null : exchange;
+}
+function normalizeIsoDate(value, field) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new ArchiveInputError(
+      `${field} must be an ISO 8601 datetime (e.g. "2024-01-01T00:00:00Z"); got ${JSON.stringify(value)}.`
+    );
+  }
+  return value;
+}
+function parseHistoryArgs(args) {
+  const from = normalizeIsoDate(args?.from, "from");
+  const to = normalizeIsoDate(args?.to, "to");
+  if (from && to && Date.parse(from) > Date.parse(to)) {
+    throw new ArchiveInputError(
+      `from (${from}) is after to (${to}) \u2014 swap the bounds.`
+    );
+  }
+  return {
+    base_coin: normalizeBaseCoin(args?.base_coin),
+    exchange: normalizeExchange(args?.exchange),
+    from,
+    to,
+    limit: clampLimit3(args?.limit)
+  };
+}
+function archiveQueryError(context, error) {
+  const detail = error.message ?? "unknown error";
+  const code = error.code ? ` (code ${error.code})` : "";
+  if (error.code === "57014" || /timeout/i.test(detail)) {
+    return new Error(
+      `Hive Archive query timed out while ${context}${code}. Narrow the time range with from/to or lower limit, then retry.`
+    );
+  }
+  if (/jwt|apikey|api key|authorization/i.test(detail)) {
+    return new Error(
+      `Hive Archive rejected the configured credentials while ${context}${code}: ${detail}. The archive key needs rotation \u2014 this is a server configuration issue, not a query problem.`
+    );
+  }
+  return new Error(
+    `Hive Archive query failed while ${context}${code}: ${detail}. Retry once; if it persists the archive is degraded \u2014 use live derivatives tools instead.`
+  );
+}
+var HISTORY_TABLES = {
+  funding: {
+    table: "funding_rates_history",
+    columns: "exchange,symbol,base_coin,rate,interval_hours,settled_at",
+    tsColumn: "settled_at"
+  },
+  open_interest: {
+    table: "futures_open_interest",
+    columns: "exchange,base_coin,symbol,open_interest_value,timestamp",
+    tsColumn: "timestamp"
+  },
+  basis: {
+    table: "futures_basis",
+    columns: "exchange,base_coin,spot_price,futures_price,basis_rate,annualized_basis,timestamp",
+    tsColumn: "timestamp"
+  },
+  long_short: {
+    table: "futures_long_short_ratio",
+    columns: "exchange,base_coin,symbol,long_ratio,short_ratio,timestamp",
+    tsColumn: "timestamp"
+  },
+  liquidations: {
+    table: "futures_liquidations",
+    columns: "exchange,base_coin,symbol,side,quantity,price,timestamp",
+    tsColumn: "timestamp"
+  }
+};
+async function fetchHistoryRows(client2, dataset, filters) {
+  const spec = HISTORY_TABLES[dataset];
+  let query = client2.from(spec.table).select(spec.columns).eq("base_coin", filters.base_coin);
+  if (filters.exchange) {
+    query = query.ilike("exchange", escapeLikeLiteral(filters.exchange));
+  }
+  if (filters.from) query = query.gte(spec.tsColumn, filters.from);
+  if (filters.to) query = query.lte(spec.tsColumn, filters.to);
+  const { data, error } = await query.order(spec.tsColumn, { ascending: false }).limit(filters.limit).abortSignal(AbortSignal.timeout(QUERY_TIMEOUT_MS));
+  if (error) {
+    throw archiveQueryError(
+      `reading ${spec.table} for ${filters.base_coin}`,
+      error
+    );
+  }
+  return data ?? [];
+}
+var coverageCache = /* @__PURE__ */ new Map();
+async function probeTimestamp(client2, spec, direction, baseCoin) {
+  let query = client2.from(spec.table).select(spec.tsColumn);
+  if (baseCoin) query = query.eq("base_coin", baseCoin);
+  const { data, error } = await query.order(spec.tsColumn, { ascending: direction === "asc" }).limit(1).abortSignal(AbortSignal.timeout(QUERY_TIMEOUT_MS));
+  if (error) {
+    throw archiveQueryError(`probing ${spec.table} coverage`, error);
+  }
+  const row = (data ?? [])[0];
+  const value = row?.[spec.tsColumn];
+  return typeof value === "string" ? value : null;
+}
+async function listFundingVenues(client2) {
+  const venues = [];
+  let cursor = null;
+  for (let step2 = 0; step2 < VENUE_SCAN_MAX_STEPS; step2++) {
+    let query = client2.from("funding_rates_history").select("exchange");
+    if (cursor !== null) query = query.gt("exchange", cursor);
+    const { data, error } = await query.order("exchange", { ascending: true }).limit(1).abortSignal(AbortSignal.timeout(QUERY_TIMEOUT_MS));
+    if (error) throw archiveQueryError("enumerating archive venues", error);
+    const row = (data ?? [])[0];
+    if (!row || typeof row.exchange !== "string") {
+      return { venues, truncated: false };
+    }
+    venues.push(row.exchange);
+    cursor = row.exchange;
+  }
+  return { venues, truncated: true };
+}
+async function fetchCoverage(client2, probeBaseCoin) {
+  const cached = coverageCache.get(probeBaseCoin);
+  if (cached && Date.now() - cached.at < COVERAGE_CACHE_TTL_MS) {
+    return { coverage: cached.payload, cache: "hit" };
+  }
+  const futuresDatasets = [
+    "open_interest",
+    "basis",
+    "long_short",
+    "liquidations"
+  ];
+  const [venueScan, fundingEarliest, fundingLatest, ...futuresExtremes] = await Promise.all([
+    listFundingVenues(client2),
+    probeTimestamp(client2, HISTORY_TABLES.funding, "asc", null),
+    probeTimestamp(client2, HISTORY_TABLES.funding, "desc", null),
+    ...futuresDatasets.flatMap((dataset) => [
+      probeTimestamp(client2, HISTORY_TABLES[dataset], "asc", probeBaseCoin),
+      probeTimestamp(client2, HISTORY_TABLES[dataset], "desc", probeBaseCoin)
+    ])
+  ]);
+  const datasets = [
+    {
+      dataset: "funding",
+      table: HISTORY_TABLES.funding.table,
+      scope: "all_coins",
+      earliest_at: fundingEarliest,
+      latest_at: fundingLatest
+    },
+    ...futuresDatasets.map((dataset, index) => {
+      return {
+        dataset,
+        table: HISTORY_TABLES[dataset].table,
+        scope: "probe_coin",
+        earliest_at: futuresExtremes[index * 2],
+        latest_at: futuresExtremes[index * 2 + 1]
+      };
+    })
+  ];
+  const coverage = {
+    venues: venueScan.venues,
+    venue_count: venueScan.venues.length,
+    venues_truncated: venueScan.truncated,
+    probe_base_coin: probeBaseCoin,
+    datasets,
+    note: `${ARCHIVE_SINCE_NOTE} (funding settlements). Futures datasets retain less history and their extremes are probed for probe_base_coin via the (base_coin, timestamp) indexes \u2014 pass base_coin to probe another asset. Venues are the all-time distinct funding exchanges.`
+  };
+  if (coverageCache.size >= COVERAGE_CACHE_MAX_ENTRIES) {
+    const oldestKey = coverageCache.keys().next().value;
+    if (oldestKey !== void 0) coverageCache.delete(oldestKey);
+  }
+  coverageCache.set(probeBaseCoin, { at: Date.now(), payload: coverage });
+  return { coverage, cache: "miss" };
+}
+
+// src/tools/archive/tools.ts
+var ARCHIVE_READ_ANNOTATIONS = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var PROVIDER_NAME = "Hive Archive";
+var SHARED_ARGS_DOC = `Args:
+  - base_coin (string, required): base asset ticker, e.g. "BTC", "ETH", "SOL" (case-insensitive; uppercased server-side).
+  - exchange (string, optional): one venue, matched case-insensitively (e.g. "Binance", "okx"). Omit for all venues.
+  - from (string, optional): ISO 8601 inclusive lower bound.
+  - to (string, optional): ISO 8601 inclusive upper bound.
+  - limit (integer, optional): max rows (1-${MAX_LIMIT2}, default ${DEFAULT_LIMIT2}), newest first.`;
+var SHARED_RETURNS_DOC = `Bounded JSON envelope: { "provider", "dataset", "runtime_status", "fetched_at", "note", "filters", "order", "returnedCount", "may_have_more", "rows" }. Rows are newest-first; may_have_more true means the limit was hit \u2014 page older data by setting "to" below the oldest returned timestamp.`;
+function historyInputSchema(baseCoinDescription) {
+  return {
+    type: "object",
+    properties: {
+      base_coin: {
+        type: "string",
+        description: baseCoinDescription
+      },
+      exchange: {
+        type: "string",
+        description: 'Venue filter, case-insensitive exact match (e.g. "Binance", "Hyperliquid"). Call archive_get_coverage for the venue list.'
+      },
+      from: {
+        type: "string",
+        description: 'Inclusive ISO 8601 lower time bound, e.g. "2024-01-01T00:00:00Z".'
+      },
+      to: {
+        type: "string",
+        description: 'Inclusive ISO 8601 upper time bound, e.g. "2024-06-30T23:59:59Z".'
+      },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: MAX_LIMIT2,
+        description: `Maximum rows to return (1-${MAX_LIMIT2}, default ${DEFAULT_LIMIT2}). Rows are ordered newest first.`
+      }
+    },
+    required: ["base_coin"]
+  };
+}
+function errorResult2(tool89, error) {
+  if (error instanceof ArchiveInputError) {
+    return asTextContentResult(
+      {
+        error: error.message,
+        runtime_status: "invalid_input",
+        tool: tool89
+      },
+      true
+    );
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return asTextContentResult(
+    {
+      error: message,
+      runtime_status: classifyRuntimeStatusFromError(message),
+      tool: tool89
+    },
+    true
+  );
+}
+function missingCredentialsResult(tool89) {
+  return asTextContentResult(
+    {
+      error: ARCHIVE_MISSING_CREDENTIALS_MESSAGE,
+      runtime_status: "missing_key",
+      tool: tool89
+    },
+    true
+  );
+}
+function historyHandler(toolName, dataset, options) {
+  return async (_client, args) => {
+    const supabase = getArchiveClient();
+    if (!supabase) return missingCredentialsResult(toolName);
+    try {
+      const filters = parseHistoryArgs(args);
+      const rows = await fetchHistoryRows(supabase, dataset, filters);
+      const mapped = options?.mapRow ? rows.map(options.mapRow) : rows;
+      const spec = HISTORY_TABLES[dataset];
+      return asTextContentResult({
+        provider: PROVIDER_NAME,
+        dataset: spec.table,
+        runtime_status: "ok",
+        fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+        note: options?.extraNote ? `${ARCHIVE_SINCE_NOTE}. ${options.extraNote}` : ARCHIVE_SINCE_NOTE,
+        filters,
+        order: `${spec.tsColumn} desc`,
+        returnedCount: mapped.length,
+        may_have_more: mapped.length === filters.limit,
+        rows: mapped
+      });
+    } catch (error) {
+      return errorResult2(toolName, error);
+    }
+  };
+}
+function getAllArchiveEndpoints() {
+  return [
+    {
+      metadata: {
+        resource: "archive-funding-history",
+        operation: "read",
+        tags: ["archive", "derivatives", "funding", "history", "cross-venue"]
+      },
+      tool: {
+        name: "archive_get_funding_history",
+        description: `Get historical perp funding-rate SETTLEMENTS for one base coin across up to 33 CEX+DEX venues from the Hive Archive (${ARCHIVE_SINCE_NOTE}; 9.8M settlement rows). Each row is one settled funding event: exchange, symbol, base_coin, rate (raw per-interval fraction), interval_hours, settled_at \u2014 plus a derived funding_annualized computed honestly from that row's own interval (rate * 8760 / interval_hours; null when the interval is unknown, never a guessed 8h default).
+
+${SHARED_ARGS_DOC}
+
+Returns:
+  ${SHARED_RETURNS_DOC}
+
+Examples:
+  - { "base_coin": "BTC", "from": "2024-01-01T00:00:00Z", "limit": 200 } \u2014 BTC settlements across venues since 2024.
+  - { "base_coin": "ETH", "exchange": "Hyperliquid", "limit": 100 } \u2014 recent ETH settlements on one venue.
+
+Use when:
+  - "BTC funding history across exchanges since 2024" \u2014 long-window, cross-venue funding studies
+  - You are computing realized carry, funding regime shifts, or venue funding divergence over time
+  - You need settlements older than what live venue APIs retain
+
+Don't use when:
+  - You need CURRENT funding (use ccxt_fetch_funding_rates_multi or hyperliquid_get_predicted_fundings)
+  - You need one venue's own raw history endpoint (use get_funding_rate_history or hyperliquid_get_funding_history)
+  - You need tokenized-stock/RWA perp funding (use rwa_get_funding_rates)`,
+        inputSchema: historyInputSchema(
+          'Base asset ticker to fetch settlements for, e.g. "BTC". Required \u2014 the archive is indexed by base coin.'
+        ),
+        annotations: ARCHIVE_READ_ANNOTATIONS
+      },
+      handler: historyHandler("archive_get_funding_history", "funding", {
+        mapRow: (row) => ({
+          ...row,
+          funding_annualized: annualizeRate(
+            Number(row.rate),
+            Number(row.interval_hours)
+          )
+        })
+      })
+    },
+    {
+      metadata: {
+        resource: "archive-open-interest-history",
+        operation: "read",
+        tags: [
+          "archive",
+          "derivatives",
+          "open-interest",
+          "history",
+          "cross-venue"
+        ]
+      },
+      tool: {
+        name: "archive_get_open_interest_history",
+        description: `Get historical perp open-interest snapshots for one base coin across venues from the Hive Archive (2.1M rows). Each row: exchange, base_coin, symbol (venue-native contract), open_interest_value (venue-reported OI as collected), timestamp. Retention is shorter than funding \u2014 call archive_get_coverage for exact per-dataset depth.
+
+${SHARED_ARGS_DOC}
+
+Returns:
+  ${SHARED_RETURNS_DOC}
+
+Examples:
+  - { "base_coin": "ETH", "from": "2026-07-18T00:00:00Z", "to": "2026-08-18T00:00:00Z" } \u2014 ETH OI over the last month.
+  - { "base_coin": "BTC", "exchange": "OKX", "limit": 500 } \u2014 recent BTC OI snapshots on OKX.
+
+Use when:
+  - "ETH open interest history last month" \u2014 OI trend and buildup/unwind analysis over time
+  - You are correlating OI changes with funding or liquidation events across venues
+
+Don't use when:
+  - You need CURRENT open interest (use ccxt_fetch_open_interest_multi or get_open_interest)
+  - You need one venue's own OI history endpoint shape (use get_open_interest_history via CCXT)`,
+        inputSchema: historyInputSchema(
+          'Base asset ticker to fetch open-interest snapshots for, e.g. "ETH". Required.'
+        ),
+        annotations: ARCHIVE_READ_ANNOTATIONS
+      },
+      handler: historyHandler(
+        "archive_get_open_interest_history",
+        "open_interest",
+        {
+          extraNote: "open_interest_value is the venue-reported figure as collected (units are venue-native)."
+        }
+      )
+    },
+    {
+      metadata: {
+        resource: "archive-basis-history",
+        operation: "read",
+        tags: ["archive", "derivatives", "basis", "history", "cross-venue"]
+      },
+      tool: {
+        name: "archive_get_basis_history",
+        description: `Get historical spot-vs-futures BASIS snapshots for one base coin across venues from the Hive Archive. Each row: exchange, base_coin, spot_price, futures_price, basis_rate (fraction), annualized_basis, timestamp \u2014 the basis fields were computed at collection time from the venue's own spot and futures quotes.
+
+${SHARED_ARGS_DOC}
+
+Returns:
+  ${SHARED_RETURNS_DOC}
+
+Examples:
+  - { "base_coin": "BTC", "from": "2026-05-01T00:00:00Z", "limit": 300 } \u2014 BTC basis regime since May.
+  - { "base_coin": "SOL", "exchange": "Binance" } \u2014 recent SOL basis snapshots on Binance.
+
+Use when:
+  - You are studying cash-and-carry yield history or basis blowouts/compressions over time
+  - You need basis context around a historical funding or liquidation event
+
+Don't use when:
+  - You need LIVE basis or dated-futures term structure right now (use ccxt_ mark/index tools or hyperliquid tools)
+  - You need current cross-venue funding instead of basis (use archive_get_funding_history for history, ccxt_fetch_funding_rates_multi for now)`,
+        inputSchema: historyInputSchema(
+          'Base asset ticker to fetch basis snapshots for, e.g. "BTC". Required.'
+        ),
+        annotations: ARCHIVE_READ_ANNOTATIONS
+      },
+      handler: historyHandler("archive_get_basis_history", "basis")
+    },
+    {
+      metadata: {
+        resource: "archive-long-short-history",
+        operation: "read",
+        tags: [
+          "archive",
+          "derivatives",
+          "long-short-ratio",
+          "positioning",
+          "history"
+        ]
+      },
+      tool: {
+        name: "archive_get_long_short_history",
+        description: `Get historical long/short-ratio snapshots for one base coin from the Hive Archive. Each row: exchange, base_coin, symbol, long_ratio, short_ratio (fractions summing to ~1), timestamp. The exchange column carries BOTH the all-account series (e.g. "Binance") and top-trader series (e.g. "Binance_top_trader") as separate venue values \u2014 filter with the exchange arg to pick one.
+
+${SHARED_ARGS_DOC}
+
+Returns:
+  ${SHARED_RETURNS_DOC}
+
+Examples:
+  - { "base_coin": "BTC", "exchange": "Binance_top_trader", "limit": 200 } \u2014 top-trader positioning history.
+  - { "base_coin": "ETH", "from": "2026-06-01T00:00:00Z" } \u2014 all ETH positioning series since June.
+
+Use when:
+  - You are studying positioning shifts (crowded longs/shorts) around historical price moves
+  - You need retail-vs-top-trader positioning divergence over time
+
+Don't use when:
+  - You need the CURRENT ratio (use get_long_short_ratio or ccxt_fetch_long_short_ratio_history for venue-native reads)
+  - You need funding or OI history (use the dedicated archive_ tools)`,
+        inputSchema: historyInputSchema(
+          'Base asset ticker to fetch long/short snapshots for, e.g. "BTC". Required.'
+        ),
+        annotations: ARCHIVE_READ_ANNOTATIONS
+      },
+      handler: historyHandler("archive_get_long_short_history", "long_short")
+    },
+    {
+      metadata: {
+        resource: "archive-liquidations-history",
+        operation: "read",
+        tags: ["archive", "derivatives", "liquidations", "history"]
+      },
+      tool: {
+        name: "archive_get_liquidations_history",
+        description: `Get historical liquidation events for one base coin from the Hive Archive. Each row: exchange, base_coin, symbol, side ("long" = longs liquidated, "short" = shorts liquidated), quantity, price, timestamp. quantity and price are the venue-reported values as collected \u2014 units are venue-native, so compare quantities only within one exchange.
+
+${SHARED_ARGS_DOC}
+
+Returns:
+  ${SHARED_RETURNS_DOC}
+
+Examples:
+  - { "base_coin": "BTC", "from": "2026-08-01T00:00:00Z", "limit": 500 } \u2014 August BTC liquidation prints.
+  - { "base_coin": "ETH", "exchange": "Binance", "limit": 100 } \u2014 recent ETH liquidations on Binance.
+
+Use when:
+  - You are reconstructing a liquidation cascade or mapping historical liquidation clusters by price
+  - You need liquidation context around a historical funding/OI/basis move
+
+Don't use when:
+  - You need LIVE liquidations (use get_liquidations via CCXT)
+  - You need aggregate liquidation totals per venue right now (live venue tools)`,
+        inputSchema: historyInputSchema(
+          'Base asset ticker to fetch liquidation events for, e.g. "BTC". Required.'
+        ),
+        annotations: ARCHIVE_READ_ANNOTATIONS
+      },
+      handler: historyHandler(
+        "archive_get_liquidations_history",
+        "liquidations"
+      )
+    },
+    {
+      metadata: {
+        resource: "archive-coverage",
+        operation: "read",
+        tags: ["archive", "derivatives", "coverage", "discovery"]
+      },
+      tool: {
+        name: "archive_get_coverage",
+        description: `Discover what the Hive Archive holds: the all-time venue list (33 CEX+DEX funding venues) and earliest/latest timestamps per dataset (funding settlements, open interest, basis, long/short ratio, liquidations). Funding extremes are global; futures-dataset extremes are probed for one base coin (default "BTC" \u2014 verified to match the global extremes) because those tables are indexed by (base_coin, timestamp). Results are cached in-process for 10 minutes.
+
+Args:
+  - base_coin (string, optional): probe coin for the futures datasets (default "BTC"). Pass another ticker to check archive depth for that asset.
+
+Returns:
+  JSON object: { "provider", "runtime_status", "fetched_at", "cache", "venues": [...], "venue_count", "venues_truncated", "probe_base_coin", "datasets": [{ "dataset", "table", "scope", "earliest_at", "latest_at" }], "note" }.
+
+Examples:
+  - {} \u2014 full coverage picture with BTC probes.
+  - { "base_coin": "DOGE" } \u2014 how far back DOGE futures datasets go.
+
+Use when:
+  - Before a history query, to learn venue names and how far back each dataset reaches
+  - "Which exchanges does the funding archive cover?" / "since when is there OI history?"
+
+Don't use when:
+  - You already know the venue and range (call the history tool directly)
+  - You need live venue universes (use ccxt_fetch_markets or venue tools)`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            base_coin: {
+              type: "string",
+              description: 'Probe coin for futures-dataset extremes (default "BTC").'
+            }
+          }
+        },
+        annotations: ARCHIVE_READ_ANNOTATIONS
+      },
+      handler: async (_client, args) => {
+        const toolName = "archive_get_coverage";
+        const supabase = getArchiveClient();
+        if (!supabase) return missingCredentialsResult(toolName);
+        try {
+          const probe = typeof args?.base_coin === "string" && args.base_coin.trim() !== "" ? args.base_coin.trim().toUpperCase() : "BTC";
+          const { coverage, cache } = await fetchCoverage(supabase, probe);
+          return asTextContentResult({
+            provider: PROVIDER_NAME,
+            runtime_status: "ok",
+            fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+            cache,
+            ...coverage
+          });
+        } catch (error) {
+          return errorResult2(toolName, error);
+        }
+      }
+    }
+  ];
+}
+
 // src/tools/fetch/allowlist.ts
 var KB = 1024;
 var FETCH_ALLOWLIST = [
@@ -81843,9 +82437,90 @@ function getOutputSchemaForTool(toolName) {
   }
   return GENERIC_TOOL_OUTPUT_SCHEMA;
 }
+var SOURCE_RECEIPT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  required: ["provider", "runtime_status", "fetched_at"],
+  properties: {
+    provider: { type: "string" },
+    tool: { type: "string" },
+    runtime_status: { type: "string", enum: [...RUNTIME_STATUSES] },
+    fetched_at: { type: "string", format: "date-time" },
+    cache_status: { type: "string" },
+    source: { type: "string" },
+    receipt_id: { type: "string" }
+  },
+  description: "Provenance for this observation: which upstream served it, its runtime status, and when it was fetched."
+};
+var RECEIPT_REF = {
+  type: "object",
+  additionalProperties: true,
+  required: ["provider", "runtime_status", "fetched_at"],
+  properties: {
+    provider: { type: "string" },
+    runtime_status: { type: "string", enum: [...RUNTIME_STATUSES] },
+    fetched_at: { type: "string", format: "date-time" }
+  }
+};
+var GET_TOKEN_PRICE_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  required: ["source_receipt"],
+  properties: {
+    source_receipt: RECEIPT_REF,
+    token: { type: "string" },
+    vs_currency: { type: "string" },
+    price: { type: "number" },
+    market_cap: { type: "number" },
+    change_24h_percent: { type: "number" }
+  }
+};
+var CHECK_TOKEN_SAFETY_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  required: ["source_receipt"],
+  properties: {
+    source_receipt: RECEIPT_REF,
+    address: { type: "string" },
+    chain: { type: "string" },
+    risk_flags: {
+      type: "object",
+      additionalProperties: true,
+      description: "Raw provider risk datapoints; '1' means flagged. A missing key means the provider did not report that signal, not that it passed."
+    },
+    holder_count: {},
+    token_name: { type: "string" },
+    note: { type: "string" }
+  }
+};
+var GET_WALLET_PORTFOLIO_OUTPUT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  required: ["source_receipt"],
+  properties: {
+    source_receipt: RECEIPT_REF,
+    address: { type: "string" },
+    chain: { type: "string" },
+    token_count: {
+      type: "number",
+      description: "Total holdings found, which may exceed tokens.length."
+    },
+    tokens: {
+      type: "array",
+      items: { type: "object", additionalProperties: true },
+      description: "Holdings; truncated in concise mode when note is present."
+    },
+    note: { type: "string" }
+  }
+};
+var HERO_TOOL_OUTPUT_SCHEMAS = {
+  get_token_price: GET_TOKEN_PRICE_OUTPUT_SCHEMA,
+  check_token_safety: CHECK_TOKEN_SAFETY_OUTPUT_SCHEMA,
+  get_wallet_portfolio: GET_WALLET_PORTFOLIO_OUTPUT_SCHEMA
+};
 
 // src/utils/analytics.ts
-import { randomUUID } from "crypto";
+import { createHash as createHash3, randomUUID } from "crypto";
 var GA_ENDPOINT = "https://www.google-analytics.com/mp/collect";
 function getMeasurementId() {
   return getEnvVar("GA_MEASUREMENT_ID");
@@ -81876,7 +82551,9 @@ async function sendEvents(clientId, events) {
   }
 }
 function deriveClientId(ip, userAgent, userId) {
-  if (userId) return userId;
+  if (userId) {
+    return `u_${createHash3("sha256").update(userId).digest("hex").slice(0, 32)}`;
+  }
   const raw = `${ip || "unknown"}_${userAgent || "unknown"}`;
   let hash = 0;
   for (let i = 0; i < raw.length; i++) {
@@ -82020,24 +82697,32 @@ async function closeRedisClient() {
     current.disconnect();
   }
 }
+var DEGRADED_AFTER_ATTEMPTS = 3;
+var MAX_RECONNECT_DELAY_MS = 3e3;
+function redisRetryStrategy(times) {
+  if (times === DEGRADED_AFTER_ATTEMPTS) {
+    secureLogger.warn(
+      `[redis] Connection failed after ${DEGRADED_AFTER_ATTEMPTS} retries, falling back to in-memory while reconnection continues`,
+      {}
+    );
+    available = false;
+  }
+  return Math.min(times * 100, MAX_RECONNECT_DELAY_MS);
+}
+function redisClientOptions() {
+  return {
+    maxRetriesPerRequest: 3,
+    retryStrategy: redisRetryStrategy,
+    lazyConnect: true
+  };
+}
 var redisUrl = getEnvVar("REDIS_URL");
+function isRedisConfigured() {
+  return Boolean(redisUrl);
+}
 if (redisUrl) {
   try {
-    client = new Redis(redisUrl, {
-      maxRetriesPerRequest: 3,
-      retryStrategy: (times) => {
-        if (times > 3) {
-          secureLogger.warn(
-            "[redis] Connection failed after 3 retries, falling back to in-memory",
-            {}
-          );
-          available = false;
-          return null;
-        }
-        return Math.min(times * 100, 1e3);
-      },
-      lazyConnect: true
-    });
+    client = new Redis(redisUrl, redisClientOptions());
     client.connect().then(() => {
       available = true;
       logRedisInfo("[redis] Connected successfully");
@@ -82313,6 +82998,24 @@ var PROVIDER_CATALOG = [
     alwaysAvailable: true,
     matches: (toolName, metadata93) => matchesProvider("hyperliquid", toolName, metadata93)
   },
+  {
+    // The Hive-native hive_archive_monitor tool contains the "_archive_"
+    // infix this matcher would accept; the "hive" entry is listed first and
+    // catalog order decides classification, so hive_ tools never land here.
+    id: "archive",
+    name: "Hive Archive",
+    prefix: "archive_",
+    type: "Cross-venue crypto derivatives history since 2023-11 (33 CEX+DEX venues): funding-rate settlements, open interest, basis, long/short ratio, and liquidations from Hive's own archive store",
+    clientStrategy: "internal",
+    credentialRequirement: {
+      label: "SHARPE_ARCHIVE_SUPABASE_URL and SHARPE_ARCHIVE_SUPABASE_SERVICE_ROLE_KEY",
+      isConfigured: () => hasAllEnvVars(
+        "SHARPE_ARCHIVE_SUPABASE_URL",
+        "SHARPE_ARCHIVE_SUPABASE_SERVICE_ROLE_KEY"
+      )
+    },
+    matches: (toolName, metadata93) => matchesProvider("archive", toolName, metadata93)
+  },
   {
     id: "fetch",
     name: "Open Data Fetch",
@@ -83089,6 +83792,7 @@ function getAllWrappedEndpoints() {
     ...getAllAlchemyEndpoints(),
     ...getAllHyperliquidEndpoints(),
     ...getAllRwaEndpoints(),
+    ...getAllArchiveEndpoints(),
     ...getAllFetchEndpoints()
   ];
   const allEndpointsJSON = wrapper;
@@ -83163,6 +83867,7 @@ function getAllWrappedEndpoints() {
         "hive_",
         "hyperliquid_",
         "rwa_",
+        "archive_",
         "fetch_"
       ];
       if (selfDescribedPrefixes.some((p) => tool89.name.startsWith(p))) {
@@ -83222,7 +83927,7 @@ var ToolRegistry = [
   {
     category: "Market Data and Price",
     name: "get_market_and_price_endpoints",
-    description: "Endpoints to retrieve real-time and historical cryptocurrency prices, market caps, trading volumes, OHLC data, global market statistics, supported currencies, basic market performance metrics across different timeframes and asset platforms, stablecoin market analytics, stablecoin price tracking, comprehensive stablecoin market cap data across multiple chains, centralized exchange (CEX) trading data including real-time tickers, order books, recent trades, candlestick charts, best bid/ask prices, CEX exchange metadata and volume charts, derivatives pricing (index, mark, and premium), perpetual futures funding rates, leverage tiers, options trading analytics, and available trading markets/currencies across major exchanges. Provider guide: Use coingecko tools for market-wide price data. Use ccxt_ tools for CEX trading data. Use alchemy_ tools for supported token price reads and EVM gas data. Use codex tools for on-chain DEX token price, chart, and volume analytics.",
+    description: "Endpoints to retrieve real-time and historical cryptocurrency prices, market caps, trading volumes, OHLC data, global market statistics, supported currencies, basic market performance metrics across different timeframes and asset platforms, stablecoin market analytics, stablecoin price tracking, comprehensive stablecoin market cap data across multiple chains, centralized exchange (CEX) trading data including real-time tickers, order books, recent trades, candlestick charts, best bid/ask prices, CEX exchange metadata and volume charts, derivatives pricing (index, mark, and premium), perpetual futures funding rates, leverage tiers, options trading analytics, and available trading markets/currencies across major exchanges. Provider guide: Use coingecko tools for market-wide price data. Use ccxt_ tools for CEX trading data. Use alchemy_ tools for supported token price reads and EVM gas data. Use codex tools for on-chain DEX token price, chart, and volume analytics. Use archive_ tools for cross-venue derivatives HISTORY (funding settlements, open interest, basis, long/short ratio, liquidations) since 2023-11.",
     tools: [
       "get_coins_index",
       "get_coins_market_data",
@@ -83289,6 +83994,15 @@ var ToolRegistry = [
       "rwa_get_avantis_markets",
       "rwa_get_lighter_markets",
       "rwa_get_extended_markets",
+      // Hive Archive cross-venue derivatives history (since 2023-11).
+      // Market data by fit, same reasoning as the RWA slice — the registry
+      // stays at 10 categories (no 11th category surface).
+      "archive_get_funding_history",
+      "archive_get_open_interest_history",
+      "archive_get_basis_history",
+      "archive_get_long_short_history",
+      "archive_get_liquidations_history",
+      "archive_get_coverage",
       "get_stablecoins",
       "get_stablecoin_chains",
       "get_stablecoin_charts_global",
@@ -83948,7 +84662,7 @@ import { z as z15 } from "zod";
 import { randomUUID as randomUUID2 } from "crypto";
 
 // packages/mcp-client/src/receipt-integrity.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function compareJsonKeys(left, right) {
   if (left === right) return 0;
   return left < right ? -1 : 1;
@@ -83973,7 +84687,7 @@ function canonicalizeHiveJson(value) {
   }
 }
 function digestHiveCanonicalJson(value) {
-  return createHash3("sha256").update(canonicalizeHiveJson(value)).digest("hex");
+  return createHash4("sha256").update(canonicalizeHiveJson(value)).digest("hex");
 }
 
 // src/utils/jsonSchemaValidator.ts
@@ -84785,6 +85499,7 @@ function getMcpCreditCost(toolName) {
 // src/services/analytics-writer.ts
 import { createHmac as createHmac2 } from "crypto";
 var PRINCIPAL_HASH_DOMAIN = "hive-analytics-principal-v1";
+var DROP_LOG_INTERVAL_MS = 6e4;
 var MAX_QUEUE_SIZE = 500;
 var FLUSH_INTERVAL_MS = 5e3;
 var FLUSH_BATCH_SIZE = 100;
@@ -84817,6 +85532,7 @@ function createAnalyticsWriter(overrides = {}) {
   };
   const queue = [];
   let dropped = 0;
+  let lastDropLoggedAt = 0;
   let timer = null;
   let flushing = null;
   function hashPrincipal(raw) {
@@ -84876,6 +85592,14 @@ function createAnalyticsWriter(overrides = {}) {
       if (!deps.isConfigured()) return false;
       if (queue.length >= deps.maxQueueSize) {
         dropped += 1;
+        const now = Date.now();
+        if (now - lastDropLoggedAt >= DROP_LOG_INTERVAL_MS) {
+          lastDropLoggedAt = now;
+          secureLogger.warn(
+            "Analytics queue is full \u2014 product-analytics rows are being dropped",
+            { table, queueSize: queue.length, droppedTotal: dropped }
+          );
+        }
         return false;
       }
       queue.push({ table, row });
@@ -85771,7 +86495,7 @@ function isSolanaChain(chain, address) {
   if (chain) return SOLANA_CHAIN_NAMES.has(normalizeChain(chain));
   return !address.trim().toLowerCase().startsWith("0x");
 }
-function errorResult2(message) {
+function errorResult3(message) {
   return {
     content: [{ type: "text", text: JSON.stringify({ error: message }) }],
     isError: true
@@ -85805,7 +86529,7 @@ function heroTools(endpoints, options = {}) {
   const executeUnderlying = async (toolName, args) => {
     const lookup = resolveEndpoint(endpoints, toolName);
     if (!lookup.ok) {
-      return errorResult2(
+      return errorResult3(
         `Underlying endpoint '${toolName}' is not registered. Call search_tools to locate the current tool for this intent.`
       );
     }
@@ -85890,12 +86614,13 @@ function heroTools(endpoints, options = {}) {
       title: "Get Token Price",
       description: 'Current price for one token. Pass token as a CoinGecko id or symbol ("bitcoin", "BTC"), or pass chain + address for a specific contract. Returns price, market cap, and 24h change with provider provenance.',
       inputSchema: zodToInputSchema2(tokenPriceSchema),
+      outputSchema: heroOutputSchema("get_token_price"),
       annotations: VOLATILE_READ_ANNOTATIONS
     },
     handler: async (_client, args) => {
       const parsed = tokenPriceSchema.safeParse(args ?? {});
       if (!parsed.success) {
-        return errorResult2(
+        return errorResult3(
           `Invalid arguments: ${JSON.stringify(parsed.error.format())}`
         );
       }
@@ -85911,7 +86636,7 @@ function heroTools(endpoints, options = {}) {
         return respond(result3, format, trimOnchainPrice(address));
       }
       if (!token) {
-        return errorResult2(
+        return errorResult3(
           'Pass token (CoinGecko id or symbol, for example "bitcoin" or "BTC"), or chain + address for a contract.'
         );
       }
@@ -85990,12 +86715,13 @@ function heroTools(endpoints, options = {}) {
       title: "Check Token Safety",
       description: "Token security screen for a contract address: honeypot, taxes, ownership, and related GoPlus risk datapoints. EVM chains use chain + address; Solana addresses are detected automatically.",
       inputSchema: zodToInputSchema2(tokenSafetySchema),
+      outputSchema: heroOutputSchema("check_token_safety"),
       annotations: VOLATILE_READ_ANNOTATIONS
     },
     handler: async (_client, args) => {
       const parsed = tokenSafetySchema.safeParse(args ?? {});
       if (!parsed.success) {
-        return errorResult2(
+        return errorResult3(
           `Invalid arguments: ${JSON.stringify(parsed.error.format())}`
         );
       }
@@ -86010,7 +86736,7 @@ function heroTools(endpoints, options = {}) {
       const normalized = normalizeChain(chain);
       const chainId = /^\d+$/.test(normalized) ? normalized : GOPLUS_CHAIN_IDS[normalized];
       if (!chainId) {
-        return errorResult2(
+        return errorResult3(
           `Unknown chain '${chain}'. Pass an EVM chain name (${Object.keys(GOPLUS_CHAIN_IDS).slice(0, 6).join(", ")}, \u2026), a numeric chain id, or "solana".`
         );
       }
@@ -86074,12 +86800,13 @@ function heroTools(endpoints, options = {}) {
       title: "Get Wallet Portfolio",
       description: "Token holdings for a wallet with balances and USD values where available. EVM chains route through Alchemy; Solana wallets are detected automatically and route through Helius.",
       inputSchema: zodToInputSchema2(walletPortfolioSchema),
+      outputSchema: heroOutputSchema("get_wallet_portfolio"),
       annotations: VOLATILE_READ_ANNOTATIONS
     },
     handler: async (_client, args) => {
       const parsed = walletPortfolioSchema.safeParse(args ?? {});
       if (!parsed.success) {
-        return errorResult2(
+        return errorResult3(
           `Invalid arguments: ${JSON.stringify(parsed.error.format())}`
         );
       }
@@ -86094,7 +86821,7 @@ function heroTools(endpoints, options = {}) {
       const normalized = normalizeChain(chain);
       const network = ALCHEMY_NETWORKS[normalized];
       if (!network) {
-        return errorResult2(
+        return errorResult3(
           `Unknown chain '${chain}'. Pass an EVM chain name (${Object.keys(ALCHEMY_NETWORKS).slice(0, 6).join(", ")}, \u2026) or "solana".`
         );
       }
@@ -86109,6 +86836,9 @@ function heroTools(endpoints, options = {}) {
   };
   return [getTokenPrice, checkTokenSafety, getWalletPortfolio];
 }
+function heroOutputSchema(name) {
+  return HERO_TOOL_OUTPUT_SCHEMAS[name];
+}
 function zodToInputSchema2(schema) {
   const jsonSchema = schema.toJSONSchema();
   const { $schema, ...rest } = jsonSchema;
@@ -87156,6 +87886,10 @@ var TASK_TOOLSET_CATALOG = [
       "get_derivatives_tickers",
       "get_open_interest_history",
       "get_funding_rate_history",
+      // Hive Archive: cross-venue derivatives history since 2023-11 for
+      // windows older than live venue APIs retain.
+      "archive_get_funding_history",
+      "archive_get_open_interest_history",
       "hyperliquid_get_perp_dexs",
       "hyperliquid_get_perps_at_oi_cap",
       "hyperliquid_get_meta",
@@ -88852,7 +89586,9 @@ function redisAdapter() {
       if (!redis || !isRedisAvailable()) {
         throw new Error("Redis is not available");
       }
-      await redis.multi().lpush(key, value).ltrim(key, 0, limit - 1).exec();
+      const results = await redis.pipeline().lpush(key, value).ltrim(key, 0, limit - 1).exec();
+      const failure = results?.find(([error]) => error)?.[0];
+      if (failure) throw failure;
     }
   };
 }
@@ -88929,13 +89665,8 @@ var CanaryHistoryStore = class {
           0,
           this.limit
         );
-        const persistedValues = new Set(
-          entries.map((entry) => JSON.stringify(entry))
-        );
-        const memoryOnly = this.memory.some(
-          (entry) => !persistedValues.has(JSON.stringify(entry))
-        );
-        const hasUnpersisted = this.unpersisted.size > 0 || memoryOnly;
+        const storeLostEverything = this.memory.length > 0 && entries.length === 0;
+        const hasUnpersisted = this.unpersisted.size > 0 || storeLostEverything;
         const requiredUnavailable = this.backend === "redis" && hasUnpersisted;
         if (!hasUnpersisted) this.lastPersistenceError = null;
         return {
@@ -90337,7 +91068,7 @@ async function runMcpProtocolHealth(options = {}) {
 }
 
 // src/health/oauthLifecycle.ts
-import { createHash as createHash5, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash6, randomBytes as randomBytes3 } from "crypto";
 
 // src/auth/oauth/provider.ts
 import { randomBytes as randomBytes2 } from "crypto";
@@ -90713,10 +91444,10 @@ function isHiveOAuthAccessToken(token) {
 }
 
 // src/auth/oauth/store.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 var REVOKED_FAMILY_TTL_SECONDS = 7776e3;
 function digest(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function parseJson(raw) {
   if (!raw) return void 0;
@@ -91168,7 +91899,7 @@ async function operationRejects(operation) {
 }
 async function issueCanaryFamily(args) {
   const verifier = randomBytes3(48).toString("base64url");
-  const challenge = createHash5("sha256").update(verifier).digest("base64url");
+  const challenge = createHash6("sha256").update(verifier).digest("base64url");
   let consentLocation;
   const response = {
     redirect(status, location) {
@@ -91480,7 +92211,7 @@ async function runOAuthLifecycleHealth(overrides = {}) {
 import Coingecko2 from "@coingecko/coingecko-typescript";
 
 // src/tools/goplus/goplusClient.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 function parsePositiveInteger(value, fallback) {
   const parsed = Number.parseInt(value || "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -91574,7 +92305,7 @@ var GoPlusClient = class {
     const time = Math.floor(Date.now() / 1e3);
     const timeStr = time.toString();
     const signInput = this.appKey + timeStr + this.appSecret;
-    const sign = createHash6("sha1").update(signInput).digest("hex");
+    const sign = createHash7("sha1").update(signInput).digest("hex");
     secureLogger.info("GoPlus: requesting access token", {
       appKeyLength: this.appKey.length,
       appSecretLength: this.appSecret.length,
@@ -92884,6 +93615,7 @@ var PROVIDER_RESOURCE_PATTERNS = [
   ["defillama", /^(defillama|get-)/],
   ["hyperliquid", /^hyperliquid(?:[.-]|$)/],
   ["rwa", /^rwa(?:[.-]|$)/],
+  ["archive", /^archive(?:[.-]|$)/],
   ["fetch", /^fetch(?:[.-]|$)/],
   ["helius", /^helius\./],
   ["moralis", /^moralis\./],
@@ -92907,6 +93639,7 @@ function classifyProvider(endpoint) {
   if (toolName.startsWith("defillama_")) return "defillama";
   if (toolName.startsWith("hyperliquid_")) return "hyperliquid";
   if (toolName.startsWith("rwa_")) return "rwa";
+  if (toolName.startsWith("archive_")) return "archive";
   if (toolName.startsWith("fetch_")) return "fetch";
   if (toolName.startsWith("hive_")) return "hive";
   return "coingecko";
@@ -92939,6 +93672,9 @@ var QUICK_PROBE_ARGS = {
   hyperliquid: { toolName: "hyperliquid_get_perp_dexs", args: {} },
   // Single-request keyless venue read (official Ostium subgraph).
   rwa: { toolName: "rwa_get_ostium_markets", args: { limit: 5 } },
+  // Cheap coverage probe (index-only extremes, 10-min in-process cache).
+  // Unset archive credentials classify as missing-key skip, not failure.
+  archive: { toolName: "archive_get_coverage", args: {} },
   fetch: {
     toolName: "fetch_public_api",
     args: { host: "api.coingecko.com", path: "/api/v3/ping" }
@@ -93042,6 +93778,8 @@ var FULL_MODE_DEFAULT_ARGS = {
   },
   // Keyless RWA venue reads: bound every full-mode probe.
   rwa: { limit: 10 },
+  // Archive history reads: BTC exists in every dataset; keep probes bounded.
+  archive: { base_coin: "BTC", limit: 5 },
   fetch: {
     host: "api.coingecko.com",
     path: "/api/v3/ping"
@@ -94389,6 +95127,7 @@ function getClientForProvider(provider, clients) {
     case "hyperliquid":
     case "fetch":
     case "defillama":
+    case "archive":
       return null;
     case "codex":
       return null;
@@ -95149,14 +95888,17 @@ var TASK_CANARY_PROBES = [
     args: { query: "bitcoin" }
   }
 ];
+var PROBE_SKIPPED = /* @__PURE__ */ Symbol("probe_skipped");
 function classifyRuntimeStatus(probeStatus, error) {
   if (probeStatus === "passed") return "ok";
-  if (probeStatus === "skipped") return "degraded";
+  if (probeStatus === "skipped") return PROBE_SKIPPED;
   return classifyRuntimeStatusFromError(error);
 }
 function aggregateTaskStatus(results) {
   if (results.length === 0) return "unknown";
-  return aggregateRuntimeStatus(results.map((result2) => result2.status));
+  const observed = results.filter((result2) => !result2.skipped).map((result2) => result2.status);
+  if (observed.length === 0) return "unknown";
+  return aggregateRuntimeStatus(observed);
 }
 async function getTaskCanaryHistory(limit = 20) {
   const safeLimit = Math.max(1, Math.min(limit, TASK_CANARY_HISTORY_LIMIT));
@@ -95219,11 +95961,14 @@ async function runTaskCanary(toolsetId) {
   const toolset = TASK_TOOLSETS.find((item) => item.id === toolsetId);
   if (!probe || !toolset) return null;
   const result2 = await runSelfTestTool(probe.toolName, probe.args);
-  const status = classifyRuntimeStatus(result2.status, result2.error);
+  const classified = classifyRuntimeStatus(result2.status, result2.error);
+  const skipped = classified === PROBE_SKIPPED;
+  const status = skipped ? "missing_key" : classified;
   return {
     toolsetId,
     label: toolset.label,
     status,
+    ...skipped && { skipped: true },
     probeToolName: probe.toolName,
     provider: result2.provider,
     description: probe.description,
@@ -95234,20 +95979,57 @@ async function runTaskCanary(toolsetId) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+var TASK_CANARY_PROBE_TIMEOUT_MS = Number.parseInt(
+  process.env.HIVE_TASK_CANARY_TIMEOUT_MS || "10000",
+  10
+);
+var TASK_CANARY_CONCURRENCY = Number.parseInt(
+  process.env.HIVE_TASK_CANARY_CONCURRENCY || "4",
+  10
+);
+async function runTaskCanaryBounded(probe) {
+  if (TASK_CANARY_PROBE_TIMEOUT_MS <= 0) return runTaskCanary(probe.toolsetId);
+  const startedAt = Date.now();
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), TASK_CANARY_PROBE_TIMEOUT_MS);
+  });
+  try {
+    const outcome = await Promise.race([runTaskCanary(probe.toolsetId), timeout]);
+    if (outcome !== "timeout") return outcome;
+    const toolset = TASK_TOOLSETS.find((item) => item.id === probe.toolsetId);
+    return {
+      toolsetId: probe.toolsetId,
+      label: toolset?.label ?? probe.toolsetId,
+      status: "degraded",
+      probeToolName: probe.toolName,
+      provider: "unknown",
+      description: probe.description,
+      duration: Date.now() - startedAt,
+      error: `Canary exceeded ${TASK_CANARY_PROBE_TIMEOUT_MS}ms and was abandoned; the provider is slow or backing off rather than returning.`,
+      requiredIdentifiers: toolset?.requiredIdentifiers ?? [],
+      stableFixtures: toolset?.stableFixtures ?? [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 async function runTaskCanariesQuick() {
   const start = Date.now();
-  const results = [];
   const interProbeDelayMs = Number.parseInt(
     process.env.HIVE_TASK_CANARY_DELAY_MS || "350",
     10
   );
-  for (const probe of TASK_CANARY_PROBES) {
-    const result2 = await runTaskCanary(probe.toolsetId);
-    if (result2) results.push(result2);
-    if (interProbeDelayMs > 0) {
-      await new Promise((resolve) => setTimeout(resolve, interProbeDelayMs));
-    }
-  }
+  const settled = await mapWithConcurrency2(
+    TASK_CANARY_PROBES,
+    TASK_CANARY_CONCURRENCY,
+    (probe) => runTaskCanaryBounded(probe),
+    interProbeDelayMs
+  );
+  const results = settled.flatMap(
+    (entry) => entry.status === "fulfilled" && entry.value ? [entry.value] : []
+  );
   const observedAt = (/* @__PURE__ */ new Date()).toISOString();
   const summary = {
     ...getCurrentCanaryIdentity(observedAt),
@@ -97213,7 +97995,7 @@ var TASK_RESULT_VALIDATION_OUTPUT_SCHEMA = {
     warnings: { type: "array", items: { type: "string" } }
   }
 };
-function errorResult3(message) {
+function errorResult4(message) {
   return {
     content: [
       {
@@ -97237,13 +98019,13 @@ function parseCursor(cursor) {
   const parsed = Number.parseInt(cursor, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
 }
-function clampLimit3(limit, defaultLimit, maxLimit) {
+function clampLimit4(limit, defaultLimit, maxLimit) {
   if (!limit || !Number.isFinite(limit)) return defaultLimit;
   return Math.min(Math.max(Math.floor(limit), 1), maxLimit);
 }
 function paginate(items, cursor, limit, defaultLimit, maxLimit) {
   const offset = parseCursor(cursor);
-  const pageSize = clampLimit3(limit, defaultLimit, maxLimit);
+  const pageSize = clampLimit4(limit, defaultLimit, maxLimit);
   const page = items.slice(offset, offset + pageSize);
   const nextOffset = offset + page.length;
   const hasMore = nextOffset < items.length;
@@ -97775,14 +98557,14 @@ function dynamicTools(endpoints, options = {}) {
     },
     handler: async (_client, args) => {
       if (!args) {
-        return errorResult3(
+        return errorResult4(
           "No endpoint provided. Pass an 'endpoint' (or 'endpoint_name') parameter with the tool name."
         );
       }
       const parsedEndpointArgs = getEndpointSchema.parse(args);
       const requestedEndpoint = parsedEndpointArgs.endpoint ?? parsedEndpointArgs.endpoint_name;
       if (!requestedEndpoint) {
-        return errorResult3(
+        return errorResult4(
           "No endpoint provided. Pass an 'endpoint' (or 'endpoint_name') parameter with the tool name."
         );
       }
@@ -97796,7 +98578,7 @@ function dynamicTools(endpoints, options = {}) {
         ...categoryTools
       ].find((endpoint2) => endpoint2.tool.name === requestedEndpoint);
       if (!lookup.ok && !metaEndpoint) {
-        return errorResult3(
+        return errorResult4(
           `Endpoint '${lookup.resolvedToolName || lookup.requestedToolName}' not found. Use a category listing tool to discover available endpoints.`
         );
       }
@@ -97831,12 +98613,12 @@ function dynamicTools(endpoints, options = {}) {
   const invokeWithPolicy = async (invoker, client2, args) => {
     const { success, data, error } = invokeEndpointSchema.safeParse(args);
     if (!success) {
-      return errorResult3(
+      return errorResult4(
         `Invalid arguments: ${JSON.stringify(error?.format())}`
       );
     }
     const invokeArgs = normalizeInvokeArgs(data);
-    if (!invokeArgs.ok) return errorResult3(invokeArgs.message);
+    if (!invokeArgs.ok) return errorResult4(invokeArgs.message);
     const lookup = resolveEndpoint(endpoints, invokeArgs.resolvedToolName);
     if (!lookup.ok) {
       return createToolNotFoundResult(
@@ -97844,7 +98626,7 @@ function dynamicTools(endpoints, options = {}) {
       ).mcpResult;
     }
     if (!endpointAllowedForInvoker(invoker, lookup.endpoint)) {
-      return errorResult3(invokerPolicyMessage(invoker, lookup.endpoint));
+      return errorResult4(invokerPolicyMessage(invoker, lookup.endpoint));
     }
     const executionContext = {
       transport: "dynamic",
@@ -97918,7 +98700,7 @@ function dynamicTools(endpoints, options = {}) {
     handler: async (_client, args) => {
       const parsed = validateTaskResultSchema.safeParse(args);
       if (!parsed.success) {
-        return errorResult3(
+        return errorResult4(
           `Invalid task result validation request: ${JSON.stringify(parsed.error.format())}`
         );
       }
@@ -97926,7 +98708,7 @@ function dynamicTools(endpoints, options = {}) {
         (entry) => entry.id === parsed.data.task_toolset_id
       );
       if (!toolset) {
-        return errorResult3(
+        return errorResult4(
           `Unknown task toolset '${parsed.data.task_toolset_id}'. Use search_tools to select a canonical id.`
         );
       }
@@ -99355,22 +100137,22 @@ function createHiveMcpServer(scope, options) {
 
 export {
   getEnvVar,
-  hasEnvVars,
   getCsvEnv,
   getNodeEnv,
   isProduction,
   getPort,
   getRateLimitMax,
+  getCredentialedRateLimitMax,
   getCorsAllowedOrigins,
   isSupabaseConfigured,
   getSupabaseAdmin,
-  getSupabaseAuthClient,
   secureLogger,
   isB2BSubjectsEnabled,
   hasSubjectSigningSecret,
   buildSubjectBodyDigest,
   resolveSubjectContext,
   materializeSubjectContext,
+  buildStatefulWriteAuditEvent,
   recordSubjectAuditEvent,
   runWithSubjectContext,
   HIVE_AUTH_USER_ARG,
@@ -99385,7 +100167,9 @@ export {
   trackOAuthFirstMaterialReceipt,
   getRedisClient,
   isRedisAvailable,
+  waitForRedisAvailability,
   closeRedisClient,
+  isRedisConfigured,
   PROVIDER_CATALOG,
   getProviderRuntimeStatus,
   READ_ENDPOINT_INVOKER,